{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MTA-LSTM-PyTorch\n",
    "\n",
    "This is an implementation of the paper [Topic-to-Essay Generation with Neural Networks](http://ir.hit.edu.cn/~xcfeng/xiaocheng%20Feng's%20Homepage_files/final-topic-essay-generation.pdf). The original work can be found [here](https://github.com/hit-computer/MTA-LSTM), which is implemented in TensorFlow and is totally out-of-date, further more, the owner doesn't seem to maintain it anymore. Therefore, I decided to re-implement it in a simple yet powerful framework, PyTorch.\n",
    "\n",
    "In this notebook, I'll show you how to build a neural network proposed in the paper step by step from scratch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Config\n",
    "\n",
    "args = {\n",
    "    'corpus_file': 'composition_small_1.txt',\n",
    "    'target_epoch': 45,\n",
    "    'checkpoint_version_name': 'small',\n",
    "    'checkpoint_epoch': 45,\n",
    "    'checkpoint_type': 'trainable',\n",
    "    'plt': True,   # not work in this notbook\n",
    "    'corpus_test_split': 0.95,\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import packages\n",
    "\n",
    "The followings are some packages that'll be used in this work. Make sure you have them installed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gensim\n",
    "from gensim.models import KeyedVectors\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch import nn, autograd, optim\n",
    "from torch.optim.lr_scheduler import ReduceLROnPlateau\n",
    "from torch.nn import Parameter, LayerNorm\n",
    "from torch.autograd import Variable\n",
    "import torch.jit as jit\n",
    "import torch.nn.functional as F\n",
    "import time\n",
    "import os\n",
    "import math\n",
    "from tqdm import tqdm\n",
    "import collections\n",
    "from collections import namedtuple\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# import matplotlib as mpl\n",
    "# import matplotlib.pyplot as plt\n",
    "# !wget \"https://noto-website-2.storage.googleapis.com/pkgs/NotoSansCJKtc-hinted.zip\"\n",
    "# !unzip NotoSansCJKtc-hinted.zip\n",
    "# !sudo mv NotoSansCJKtc-Black.otf /usr/share/fonts/truetype/\n",
    "# !sudo mv NotoSansCJKtc-Bold.otf /usr/share/fonts/truetype/\n",
    "# !sudo mv NotoSansCJKtc-DemiLight.otf /usr/share/fonts/truetype/\n",
    "# !sudo mv NotoSansCJKtc-Light.otf /usr/share/fonts/truetype/\n",
    "# !sudo mv NotoSansCJKtc-Medium.otf /usr/share/fonts/truetype/\n",
    "# !sudo mv NotoSansCJKtc-Regular.otf /usr/share/fonts/truetype/\n",
    "# !sudo mv NotoSansCJKtc-Thin.otf /usr/share/fonts/truetype/\n",
    "# !sudo mv NotoSansMonoCJKtc-Bold.otf /usr/share/fonts/truetype/\n",
    "# !sudo mv NotoSansMonoCJKtc-Regular.otf /usr/share/fonts/truetype/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.font_manager as fm\n",
    "import matplotlib.font_manager as font_manager\n",
    "\n",
    "font_dirs = ['/fonts/', ]\n",
    "font_files = font_manager.findSystemFonts(fontpaths=font_dirs)\n",
    "\n",
    "# The createFontList function was deprecated in Matplotlib 3.2 and will be removed two minor releases later. Use FontManager.addfont instead.\n",
    "# font_list = font_manager.createFontList(font_files)\n",
    "# font_manager.fontManager.ttflist.extend(font_list)\n",
    "for font_file in font_files:\n",
    "    font_manager.fontManager.addfont(font_file)\n",
    "\n",
    "path = 'fonts/NotoSansSC-Regular.otf'\n",
    "fontprop = fm.FontProperties(fname=path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available cuda: 0\n"
     ]
    }
   ],
   "source": [
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0,1\"\n",
    "print('Available cuda:', torch.cuda.device_count())\n",
    "if torch.cuda.is_available():\n",
    "    device_num = 1\n",
    "    deviceName = \"cuda:%d\" % device_num\n",
    "    torch.cuda.set_device(device_num)\n",
    "    print('Current device:', torch.cuda.current_device())\n",
    "else:\n",
    "    deviceName = \"cpu\"\n",
    "    \n",
    "device = torch.device(deviceName)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build a dictionary and pretrained embedding system\n",
    "\n",
    "Here I'm gonna load the pretrained word2vec vocab and vectors. Please refer to [this notebook]() to he how to train it.\n",
    "\n",
    "The code ```fvec.vectors``` is where we get the pretrained vectors.\n",
    "```<PAD>```, ```<BOS>```, ```<EOS>``` and ```<UNK>``` are 4 common tokens which stands for **PADding**, **Begin-Of-Sentence**, **End-Of-Sentence** and **UNKnown** respectively. We simply add them into the vocabularies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 189613 words\n"
     ]
    }
   ],
   "source": [
    "save_folder = 'model_result_multi_layer'\n",
    "\n",
    "vocab_check_point = '%s/vocab.pkl' % save_folder\n",
    "word_vec_check_point = '%s/word_vec.pkl' % save_folder\n",
    "\n",
    "if os.path.exists(vocab_check_point) and os.path.exists(word_vec_check_point):\n",
    "    vocab = torch.load(vocab_check_point)\n",
    "    word_vec = torch.load(word_vec_check_point)\n",
    "else:\n",
    "    file_path = 'data/'\n",
    "    \n",
    "    fvec = KeyedVectors.load_word2vec_format(file_path+'composition_mincount_1_305000_vec_original.txt', binary=False)\n",
    "    \n",
    "    word_vec = fvec.vectors\n",
    "    \n",
    "    vocab = ['<PAD>', '<BOS>', '<EOS>', '<UNK>']\n",
    "    vocab.extend(list(fvec.index_to_key))\n",
    "    \n",
    "    word_vec = np.concatenate((np.array([[0]*word_vec.shape[1]] * 4), word_vec))\n",
    "    word_vec = torch.tensor(word_vec).float()\n",
    "    \n",
    "    del fvec\n",
    "    \n",
    "    torch.save(vocab, vocab_check_point)\n",
    "    torch.save(word_vec, word_vec_check_point)\n",
    "    \n",
    "print(\"total %d words\" % len(word_vec))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build a word-index convertor\n",
    "\n",
    "We don't want to use type of string directly when training, instead we map them to a unique index in integer. In text generation phase, we'll then convert them back to string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_to_idx = {ch: i for i, ch in enumerate(vocab)}\n",
    "idx_to_word = {i: ch for i, ch in enumerate(vocab)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load preprocessed data\n",
    "\n",
    "You can prepare for your own data, or simply use what I offered in the data folder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10000/10000 [00:00<00:00, 39617.94it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "essays = []\n",
    "topics = []\n",
    "\n",
    "file_path = 'data/'\n",
    "file_name = args['corpus_file']  ### TODO\n",
    "\n",
    "num_lines = sum(1 for line in open(file_path+file_name, 'r'))\n",
    "with open(file_path+file_name) as f:\n",
    "    for line in tqdm(f, total=num_lines):\n",
    "        essay, topic = line.replace('\\n', '').split(' </d> ')\n",
    "        essays.append(essay.split(' '))\n",
    "        topics.append(topic.split(' '))\n",
    "#     f.close()\n",
    "    \n",
    "assert len(topics) == len(essays)\n",
    "print(len(topics))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We then map all the training and testing corpus to integer index word-by-word, with the help of our convertor. Note that we map it to ```<UNK>``` if the words in corpus are not in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9500/9500 [00:00<00:00, 53483.91it/s]\n",
      "100%|██████████| 9500/9500 [00:00<00:00, 321999.98it/s]\n",
      "100%|██████████| 500/500 [00:00<00:00, 44466.04it/s]\n",
      "100%|██████████| 500/500 [00:00<00:00, 142382.51it/s]\n"
     ]
    }
   ],
   "source": [
    "split_index = int(len(topics) * args['corpus_test_split'])\n",
    "\n",
    "corpus_indice = list(map(lambda x: [word_to_idx[w] if (w in word_to_idx) else word_to_idx['<UNK>'] for w in x], tqdm(essays[:split_index])))\n",
    "topics_indice = list(map(lambda x: [word_to_idx[w] if (w in word_to_idx) else word_to_idx['<UNK>'] for w in x], tqdm(topics[:split_index])))\n",
    "corpus_test = list(map(lambda x: [word_to_idx[w] if (w in word_to_idx) else word_to_idx['<UNK>'] for w in x], tqdm(essays[split_index:])))\n",
    "topics_test = list(map(lambda x: [word_to_idx[w] if (w in word_to_idx) else word_to_idx['<UNK>'] for w in x], tqdm(topics[split_index:])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def viewData(topics, X):\n",
    "    topics = [idx_to_word[x] for x in topics]\n",
    "    X = [idx_to_word[x] for x in X]\n",
    "    print(topics, X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import shuffle\n",
    "\n",
    "def shuffleData(topics_indice, corpus_indice):\n",
    "    ind_list = [i for i in range(len(topics_indice))]\n",
    "    shuffle(ind_list)\n",
    "    topics_indice = np.array(topics_indice)\n",
    "    corpus_indice = np.array(corpus_indice)\n",
    "    topics_indice = topics_indice[ind_list,]\n",
    "    corpus_indice = corpus_indice[ind_list,]\n",
    "    topics_indice = topics_indice.tolist()\n",
    "    corpus_indice = corpus_indice.tolist()\n",
    "    return topics_indice, corpus_indice\n",
    "\n",
    "# topics_indice, corpus_indice = shuffleData(topics_indice, corpus_indice)\n",
    "# viewData(topics_indice[0], corpus_indice[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "for t in topics_indice:\n",
    "    if len(t) != 5:\n",
    "        print('less than 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to know the max length of training corpus too, in order to pad sequences that aren't long enough."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "length = list(map(lambda x: len(x), corpus_indice))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Delete useless dependencies to free up some space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "del essays\n",
    "del topics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch data iterator\n",
    "\n",
    "We want to iter through training data in batches and feed them into the network, and this is how we prepare for it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_iterator(corpus_indice, topics_indice, batch_size, num_steps):\n",
    "    epoch_size = len(corpus_indice) // batch_size\n",
    "    for i in range(epoch_size):\n",
    "        raw_data = corpus_indice[i*batch_size: (i+1)*batch_size]\n",
    "        key_words = topics_indice[i*batch_size: (i+1)*batch_size]\n",
    "        data = np.zeros((len(raw_data), num_steps+1), dtype=np.int64)\n",
    "        for i in range(batch_size):\n",
    "            doc = raw_data[i]\n",
    "            tmp = [1]\n",
    "            tmp.extend(doc)\n",
    "            tmp.extend([2])\n",
    "            tmp = np.array(tmp, dtype=np.int64)\n",
    "            _size = tmp.shape[0]\n",
    "            data[i][:_size] = tmp\n",
    "        key_words = np.array(key_words, dtype=np.int64)\n",
    "        x = data[:, 0:num_steps]\n",
    "        y = data[:, 1:]\n",
    "        mask = np.float32(x != 0)\n",
    "        x = torch.tensor(x)\n",
    "        y = torch.tensor(y)\n",
    "        mask = torch.tensor(mask)\n",
    "        key_words = torch.tensor(key_words)\n",
    "        yield(x, y, mask, key_words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build model: MTA-LSTM\n",
    "\n",
    "This is the most important part in the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bahdanau Attention"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Attention(nn.Module):\n",
    "    \"\"\"Implements Bahdanau (MLP) attention\"\"\"\n",
    "    \n",
    "    def __init__(self, hidden_size, embed_size):\n",
    "        super(Attention, self).__init__()\n",
    "        \n",
    "        self.Ua = nn.Linear(embed_size, hidden_size, bias=False)\n",
    "        self.Wa = nn.Linear(hidden_size, hidden_size, bias=False)\n",
    "        self.va = nn.Linear(hidden_size, 1, bias=True)\n",
    "        # to store attention scores\n",
    "        self.alphas = None\n",
    "        \n",
    "    def forward(self, query, topics, coverage_vector):\n",
    "        scores = []\n",
    "        C_t = coverage_vector.clone()\n",
    "        for i in range(topics.shape[1]):\n",
    "            proj_key = self.Ua(topics[:, i, :])\n",
    "            query = self.Wa(query)\n",
    "            scores += [self.va(torch.tanh(query + proj_key)) * C_t[:, i:i+1]]\n",
    "            \n",
    "        # stack scores\n",
    "        scores = torch.stack(scores, dim=1)\n",
    "        scores = scores.squeeze(2)\n",
    "#         print(scores.shape)\n",
    "        # turn scores to probabilities\n",
    "        alphas = F.softmax(scores, dim=1)\n",
    "        self.alphas = alphas\n",
    "        \n",
    "        # mt vector is the weighted sum of the topics\n",
    "        mt = torch.bmm(alphas.unsqueeze(1), topics)\n",
    "        mt = mt.squeeze(1)\n",
    "        \n",
    "        # mt shape: [batch x embed], alphas shape: [batch x num_keywords]\n",
    "        return mt, alphas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attention Decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AttentionDecoder(nn.Module):\n",
    "    def __init__(self, hidden_size, embed_size, num_layers, dropout=0.5):\n",
    "        super(AttentionDecoder, self).__init__()\n",
    "        \n",
    "        self.hidden_size = hidden_size\n",
    "        self.embed_size = embed_size\n",
    "        self.num_layers = num_layers\n",
    "        self.dropout = dropout\n",
    "        \n",
    "        # topic attention\n",
    "        self.attention = Attention(hidden_size, embed_size)\n",
    "        \n",
    "        # lstm\n",
    "        self.rnn = nn.LSTM(input_size=embed_size * 2, \n",
    "                           hidden_size=hidden_size, \n",
    "                           num_layers=num_layers, \n",
    "                           dropout=dropout)\n",
    "        \n",
    "    def forward(self, input, output, hidden, phi, topics, coverage_vector):\n",
    "        # 1. calculate attention weight and mt\n",
    "        mt, score = self.attention(output.squeeze(0), topics, coverage_vector)\n",
    "        mt = mt.unsqueeze(1).permute(1, 0, 2)\n",
    "        \n",
    "        # 2. update coverge vector [batch x num_keywords]\n",
    "        coverage_vector = coverage_vector - score / phi\n",
    "        \n",
    "        # 3. concat input and Tt, and feed into rnn \n",
    "        output, hidden = self.rnn(torch.cat([input, mt], dim=2), hidden)\n",
    "        \n",
    "        return output, hidden, score, coverage_vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### MTA-LSTM model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "LSTMState = namedtuple('LSTMState', ['hx', 'cx'])\n",
    "class MTALSTM(nn.Module):\n",
    "    def __init__(self, hidden_dim, embed_dim, num_keywords, num_layers, weight,\n",
    "                 num_labels, bidirectional, dropout=0.5, **kwargs):\n",
    "        super(MTALSTM, self).__init__(**kwargs)\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.embed_dim = embed_dim\n",
    "        self.num_layers = num_layers\n",
    "        self.num_labels = num_labels\n",
    "        self.bidirectional = bidirectional\n",
    "        if num_layers <= 1:\n",
    "            self.dropout = 0\n",
    "        else:\n",
    "            self.dropout = dropout\n",
    "        self.embedding = nn.Embedding.from_pretrained(weight)\n",
    "        self.embedding.weight.requires_grad = False\n",
    "        self.Uf = nn.Linear(embed_dim * num_keywords, num_keywords, bias=False)\n",
    "        \n",
    "        # attention decoder\n",
    "        self.decoder = AttentionDecoder(hidden_size=hidden_dim, \n",
    "                                        embed_size=embed_dim, \n",
    "                                        num_layers=num_layers, \n",
    "                                        dropout=dropout)\n",
    "        \n",
    "        # adaptive softmax\n",
    "        self.adaptiveSoftmax = nn.AdaptiveLogSoftmaxWithLoss(hidden_dim, \n",
    "                                                             num_labels, \n",
    "                                                             cutoffs=[round(num_labels / 20), 4*round(num_labels / 20)])\n",
    "    \n",
    "    def forward(self, inputs, topics, output, hidden=None, mask=None, target=None, coverage_vector=None, seq_length=None):\n",
    "        embeddings = self.embedding(inputs)\n",
    "        topics_embed = self.embedding(topics)\n",
    "        ''' calculate phi [batch x num_keywords] '''\n",
    "        phi = None\n",
    "        phi = torch.sum(mask, dim=1, keepdim=True) * torch.sigmoid(self.Uf(topics_embed.reshape(topics_embed.shape[0], -1).float()))\n",
    "        \n",
    "        # loop through sequence\n",
    "        inputs = embeddings.permute([1, 0, 2]).unbind(0)\n",
    "        output_states = []\n",
    "        attn_weight = []\n",
    "        for i in range(len(inputs)):\n",
    "            output, hidden, score, coverage_vector = self.decoder(input=inputs[i].unsqueeze(0), \n",
    "                                                                        output=output, \n",
    "                                                                        hidden=hidden, \n",
    "                                                                        phi=phi, \n",
    "                                                                        topics=topics_embed, \n",
    "                                                                        coverage_vector=coverage_vector) # [seq_len x batch x embed_size]\n",
    "            output_states += [output]\n",
    "            attn_weight += [score]\n",
    "            \n",
    "        output_states = torch.stack(output_states)\n",
    "        attn_weight = torch.stack(attn_weight)\n",
    "        \n",
    "        # calculate loss py adaptiveSoftmax\n",
    "        outputs = self.adaptiveSoftmax(output_states.reshape(-1, output_states.shape[-1]), target.t().reshape((-1,)))\n",
    "        \n",
    "        return outputs, output_states, hidden, attn_weight, coverage_vector\n",
    "    \n",
    "    def inference(self, inputs, topics, output, hidden=None, mask=None, coverage_vector=None, seq_length=None):\n",
    "        embeddings = self.embedding(inputs)\n",
    "        topics_embed = self.embedding(topics)\n",
    "       \n",
    "        phi = None\n",
    "        phi = seq_length.float() * torch.sigmoid(self.Uf(topics_embed.reshape(topics_embed.shape[0], -1).float()))\n",
    "        \n",
    "        queries = embeddings.permute([1, 0, 2])[-1].unsqueeze(0)\n",
    "        \n",
    "        inputs = queries.permute([1, 0, 2]).unbind(0)\n",
    "        output_states = []\n",
    "        attn_weight = []\n",
    "        for i in range(len(inputs)):\n",
    "            output, hidden, score, coverage_vector = self.decoder(input=inputs[i].unsqueeze(0), \n",
    "                                                                        output=output, \n",
    "                                                                        hidden=hidden, \n",
    "                                                                        phi=phi, \n",
    "                                                                        topics=topics_embed, \n",
    "                                                                        coverage_vector=coverage_vector) # [seq_len x batch x embed_size]\n",
    "            output_states += [output]\n",
    "            attn_weight += [score]\n",
    "            \n",
    "        output_states = torch.stack(output_states)\n",
    "        attn_weight = torch.stack(attn_weight)\n",
    "        \n",
    "        outputs = self.adaptiveSoftmax.log_prob(output_states.reshape(-1, output_states.shape[-1]))\n",
    "        return outputs, output_states, hidden, attn_weight, coverage_vector\n",
    "    \n",
    "    def init_hidden(self, batch_size):\n",
    "#         hidden = torch.zeros(num_layers, batch_size, hidden_dim)\n",
    "#         hidden = LSTMState(torch.zeros(batch_size, hidden_dim).to(device), torch.zeros(batch_size, hidden_dim).to(device))\n",
    "        hidden = (torch.zeros(self.num_layers, batch_size, self.hidden_dim).to(device), \n",
    "                  torch.zeros(self.num_layers, batch_size, self.hidden_dim).to(device))\n",
    "        return hidden\n",
    "    \n",
    "    def init_coverage_vector(self, batch_size, num_keywords):\n",
    "#         self.coverage_vector = torch.ones([batch_size, num_keywords]).to(device)\n",
    "        return torch.ones([batch_size, num_keywords]).to(device)\n",
    "#         print(self.coverage_vector)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Greedy decode strategy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pad_topic(topics):\n",
    "    topics = [word_to_idx[x] for x in topics]\n",
    "    topics = torch.tensor(topics)\n",
    "    print(topics)\n",
    "    max_num = 5\n",
    "    size = 1\n",
    "    ans = np.zeros((size, max_num), dtype=int)\n",
    "    for i in range(size):\n",
    "        true_len = min(len(topics), max_num)\n",
    "        for j in range(true_len):\n",
    "            print(topics[i])\n",
    "            ans[i][j] = topics[i][j]\n",
    "    return ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_rnn(topics, num_chars, model, idx_to_word, word_to_idx):\n",
    "    output_idx = [1]\n",
    "    topics = [word_to_idx[x] for x in topics]\n",
    "    topics = torch.tensor(topics)\n",
    "    topics = topics.reshape((1, topics.shape[0]))\n",
    "#     hidden = torch.zeros(num_layers, 1, hidden_dim)\n",
    "#     hidden = (torch.zeros(num_layers, 1, hidden_dim).to(device), torch.zeros(num_layers, 1, hidden_dim).to(device))\n",
    "    hidden = model.init_hidden(batch_size=1)\n",
    "    if use_gpu:\n",
    "#         hidden = hidden.cuda()\n",
    "        adaptive_softmax.to(device)\n",
    "        topics = topics.to(device)\n",
    "    coverage_vector = model.init_coverage_vector(topics.shape[0], topics.shape[1])\n",
    "    attentions = torch.zeros(num_chars, topics.shape[1])\n",
    "    for t in range(num_chars):\n",
    "        X = torch.tensor(output_idx[-1]).reshape((1, 1))\n",
    "#         X = torch.tensor(output).reshape((1, len(output)))\n",
    "        if use_gpu:\n",
    "            X = X.to(device)\n",
    "        if t == 0:\n",
    "            output = torch.zeros(1, hidden_dim).to(device)\n",
    "        else:\n",
    "            output = output.squeeze(0)\n",
    "        pred, output, hidden, attn_weight, coverage_vector = model.inference(inputs=X, topics=topics, output=output, hidden=hidden, coverage_vector=coverage_vector, seq_length=torch.tensor(50).reshape(1, 1).to(device))\n",
    "#         print(coverage_vector)\n",
    "        pred = pred.argmax(dim=1) # greedy strategy\n",
    "        attentions[t] = attn_weight[0].data\n",
    "#         pred = adaptive_softmax.predict(pred)\n",
    "        if pred[-1] == 2:\n",
    "#         if pred.argmax(dim=1)[-1] == 2:\n",
    "            break\n",
    "        else:\n",
    "            output_idx.append(int(pred[-1]))\n",
    "#             output.append(int(pred.argmax(dim=1)[-1]))\n",
    "    return(''.join([idx_to_word[i] for i in output_idx[1:]]), [idx_to_word[i] for i in output_idx[1:]], attentions[:t+1].t(), output_idx[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nonsense\n",
    "\n",
    "# test = [1, 15, 23]\n",
    "# test = np.array(test, dtype=np.int64)\n",
    "# mm = np.float32(test != 0)\n",
    "# mm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Beam search strategy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def beam_search(topics, num_chars, model, idx_to_word, word_to_idx, is_sample=False):\n",
    "    output_idx = [1]\n",
    "    topics = [word_to_idx[x] for x in topics]\n",
    "    topics = torch.tensor(topics)\n",
    "    topics = topics.reshape((1, topics.shape[0]))\n",
    "#     hidden = torch.zeros(num_layers, 1, hidden_dim)\n",
    "#     hidden = (torch.zeros(num_layers, 1, hidden_dim).to(device), torch.zeros(num_layers, 1, hidden_dim).to(device))\n",
    "    hidden = model.init_hidden(batch_size=1)\n",
    "    if use_gpu:\n",
    "#         hidden = hidden.cuda()\n",
    "        adaptive_softmax.to(device)\n",
    "        topics = topics.to(device)\n",
    "        seq_length = torch.tensor(50).reshape(1, 1).to(device)\n",
    "    \"\"\"1\"\"\"    \n",
    "    coverage_vector = model.init_coverage_vector(topics.shape[0], topics.shape[1])\n",
    "    attentions = torch.zeros(num_chars, topics.shape[1])\n",
    "    X = torch.tensor(output_idx[-1]).reshape((1, 1)).to(device)\n",
    "    output = torch.zeros(1, hidden_dim).to(device)\n",
    "    log_prob, output, hidden, attn_weight, coverage_vector = model.inference(inputs=X, \n",
    "                                                                   topics=topics, \n",
    "                                                                   output=output, \n",
    "                                                                   hidden=hidden, \n",
    "                                                                   coverage_vector=coverage_vector, \n",
    "                                                                   seq_length=seq_length)\n",
    "    log_prob = log_prob.cpu().detach().reshape(-1).numpy()\n",
    "#     print(log_prob[10])\n",
    "    \"\"\"2\"\"\"\n",
    "    if is_sample:\n",
    "        top_indices = np.random.choice(vocab_size, beam_size, replace=False, p=np.exp(log_prob))\n",
    "    else:\n",
    "        top_indices = np.argsort(-log_prob)\n",
    "    \"\"\"3\"\"\"\n",
    "    beams = [(0.0, [idx_to_word[1]], idx_to_word[1], torch.zeros(1, topics.shape[1]), torch.ones(1, topics.shape[1]))]\n",
    "    b = beams[0]\n",
    "    beam_candidates = []\n",
    "#     print(attn_weight[0].cpu().data, coverage_vector)\n",
    "#     assert False\n",
    "    for i in range(beam_size):\n",
    "        word_idx = top_indices[i]\n",
    "        beam_candidates.append((b[0]+log_prob[word_idx], b[1]+[idx_to_word[word_idx]], word_idx, torch.cat((b[3], attn_weight[0].cpu().data), 0), torch.cat((b[4], coverage_vector.cpu().data), 0), hidden, output.squeeze(0), coverage_vector))\n",
    "    \"\"\"4\"\"\"\n",
    "    beam_candidates.sort(key = lambda x:x[0], reverse = True) # decreasing order\n",
    "    beams = beam_candidates[:beam_size] # truncate to get new beams\n",
    "    \n",
    "    for xy in range(num_chars-1):\n",
    "        beam_candidates = []\n",
    "        for b in beams:\n",
    "            \"\"\"5\"\"\"\n",
    "            X = torch.tensor(b[2]).reshape((1, 1)).to(device)\n",
    "            \"\"\"6\"\"\"\n",
    "            log_prob, output, hidden, attn_weight, coverage_vector = model.inference(inputs=X, \n",
    "                                                                           topics=topics, \n",
    "                                                                           output=b[6], \n",
    "                                                                           hidden=b[5], \n",
    "                                                                           coverage_vector=b[7], \n",
    "                                                                           seq_length=seq_length)\n",
    "            log_prob = log_prob.cpu().detach().reshape(-1).numpy()\n",
    "            \"\"\"8\"\"\"\n",
    "            if is_sample:\n",
    "                top_indices = np.random.choice(vocab_size, beam_size, replace=False, p=np.exp(log_prob))\n",
    "            else:\n",
    "                top_indices = np.argsort(-log_prob)\n",
    "            \"\"\"9\"\"\"\n",
    "            for i in range(beam_size):\n",
    "                word_idx = top_indices[i]\n",
    "                beam_candidates.append((b[0]+log_prob[word_idx], b[1]+[idx_to_word[word_idx]], word_idx, torch.cat((b[3], attn_weight[0].cpu().data), 0), torch.cat((b[4], coverage_vector.cpu().data), 0), hidden, output.squeeze(0), coverage_vector))\n",
    "        \"\"\"10\"\"\"\n",
    "        beam_candidates.sort(key = lambda x:x[0], reverse = True) # decreasing order\n",
    "        beams = beam_candidates[:beam_size] # truncate to get new beams\n",
    "    \n",
    "    \"\"\"11\"\"\"\n",
    "    if '<EOS>' in beams[0][1]:\n",
    "        first_eos = beams[0][1].index('<EOS>')\n",
    "    else:\n",
    "        first_eos = num_chars-1\n",
    "    return(''.join(beams[0][1][:first_eos]), beams[0][1][:first_eos], beams[0][3][:first_eos].t(), beams[0][4][:first_eos])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Attention visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.switch_backend('agg')\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "    \n",
    "def showAttention(input_sentence, output_words, attentions):\n",
    "    # Set up figure with colorbar\n",
    "    fig = plt.figure()\n",
    "    ax = fig.subplots(1)\n",
    "#     cmap = 'bone'\n",
    "    cmap = 'viridis'\n",
    "    cax = ax.matshow(attentions.numpy(), cmap=cmap)\n",
    "    fig.colorbar(cax)\n",
    "\n",
    "    # Set up axes\n",
    "    ax.set_yticklabels([''] + input_sentence.split(' '), fontproperties=fontprop, fontsize=10)\n",
    "    ax.set_xticklabels([''] + output_words, fontproperties=fontprop, fontsize=10, rotation=45)\n",
    "\n",
    "    # Show label at every tick\n",
    "    ax.xaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "    ax.yaxis.set_major_locator(ticker.MultipleLocator(1))\n",
    "    \n",
    "    word_size = 0.5\n",
    "    fig.set_figheight(word_size * len(input_sentence.split(' ')))\n",
    "    fig.set_figwidth(word_size * len(output_words))\n",
    "    plt.show()\n",
    "\n",
    "def evaluateAndShowAttention(input_sentence, method='beam_search', is_sample=False):\n",
    "    if method == 'beam_search':\n",
    "        _, output_words, attentions, coverage_vector = beam_search(input_sentence, 100, model, idx_to_word, word_to_idx, is_sample=is_sample)\n",
    "    else:\n",
    "        _, output_words, attentions, _ = predict_rnn(input_sentence, 100, model, idx_to_word, word_to_idx)\n",
    "    print('input =', ' '.join(input_sentence))\n",
    "    print('output =', ' '.join(output_words))\n",
    "#     n_digits = 3\n",
    "#     coverage_vector = torch.round(coverage_vector * 10**n_digits) / (10**n_digits)\n",
    "#     coverage_vector=np.round(coverage_vector, n_digits)\n",
    "#     print(coverage_vector.numpy())\n",
    "    showAttention(' '.join(input_sentence), output_words, attentions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bleu score calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install nltk -i https://pypi.tuna.tsinghua.edu.cn/simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.translate.bleu_score import sentence_bleu, corpus_bleu, SmoothingFunction\n",
    "\n",
    "def evaluate_bleu(model, topics_test, corpus_test, num_test, method='beam_search', is_sample=False):\n",
    "    bleu_2_score = 0\n",
    "    for i in tqdm(range(len(corpus_test[:num_test]))):\n",
    "        if method == 'beam_search':\n",
    "            _, output_words, _, _ = beam_search([idx_to_word[x] for x in topics_test[i]], 100, model, idx_to_word, word_to_idx, is_sample)\n",
    "        else:\n",
    "            _, output_words, _, _ = predict_rnn([idx_to_word[x] for x in topics_test[i]], 100, model, idx_to_word, word_to_idx)\n",
    "        bleu_2_score += sentence_bleu([[idx_to_word[x] for x in corpus_test[i] if x not in [0, 2]]], output_words, weights=(0, 1, 0, 0))\n",
    "        \n",
    "    bleu_2_score = bleu_2_score / num_test * 100\n",
    "    return bleu_2_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some configurations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "embedding_dim = 100\n",
    "hidden_dim = 512\n",
    "lr = 1e-3 * 0.5\n",
    "momentum = 0.01\n",
    "num_epoch = args['target_epoch']      ### TODO: 100\n",
    "clip_value = 0.1\n",
    "use_gpu = True     # can not be False\n",
    "num_layers = 2\n",
    "bidirectional = False\n",
    "batch_size = 32\n",
    "num_keywords = 5\n",
    "verbose = 1\n",
    "check_point = 5\n",
    "beam_size = 2\n",
    "is_sample = True\n",
    "vocab_size = len(vocab)\n",
    "# device = torch.device(deviceName)\n",
    "loss_function = nn.NLLLoss()\n",
    "adaptive_softmax = nn.AdaptiveLogSoftmaxWithLoss(\n",
    "    1000, len(vocab), cutoffs=[round(vocab_size / 20), 4*round(vocab_size / 20)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# config = {\n",
    "#     \"embedding_dim\": 100, \n",
    "#     \"hidden_dim\": 512, \n",
    "#     \"batch_size\": 64, \n",
    "#     \"num_keywords\": 5, \n",
    "#     \"lr\": 1e-3 * 0.5, \n",
    "#     \"momentum\": 0.01, \n",
    "#     \"num_epoch\": 100, \n",
    "#     \"clip_value\": 1, \n",
    "#     \"use_gpu\": True, \n",
    "#     \"num_layers\": 1, \n",
    "#     \"bidirectional\": False, \n",
    "#     \"verbose\": 1, \n",
    "#     \"check_point\": 5, \n",
    "#     \"beam_size\": 2, \n",
    "#     \"is_sample\": True, \n",
    "#     \"vocab_size\": len(vocab), \n",
    "#     \"device\": torch.device(deviceName)\n",
    "# }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://github.com/LiyuanLucasLiu/RAdam\n",
    "\n",
    "import math\n",
    "import torch\n",
    "from torch.optim.optimizer import Optimizer, required\n",
    "\n",
    "class RAdam(Optimizer):\n",
    "\n",
    "    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0, degenerated_to_sgd=False):\n",
    "        if not 0.0 <= lr:\n",
    "            raise ValueError(\"Invalid learning rate: {}\".format(lr))\n",
    "        if not 0.0 <= eps:\n",
    "            raise ValueError(\"Invalid epsilon value: {}\".format(eps))\n",
    "        if not 0.0 <= betas[0] < 1.0:\n",
    "            raise ValueError(\"Invalid beta parameter at index 0: {}\".format(betas[0]))\n",
    "        if not 0.0 <= betas[1] < 1.0:\n",
    "            raise ValueError(\"Invalid beta parameter at index 1: {}\".format(betas[1]))\n",
    "        \n",
    "        self.degenerated_to_sgd = degenerated_to_sgd\n",
    "        if isinstance(params, (list, tuple)) and len(params) > 0 and isinstance(params[0], dict):\n",
    "            for param in params:\n",
    "                if 'betas' in param and (param['betas'][0] != betas[0] or param['betas'][1] != betas[1]):\n",
    "                    param['buffer'] = [[None, None, None] for _ in range(10)]\n",
    "        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay, buffer=[[None, None, None] for _ in range(10)])\n",
    "        super(RAdam, self).__init__(params, defaults)\n",
    "\n",
    "    def __setstate__(self, state):\n",
    "        super(RAdam, self).__setstate__(state)\n",
    "\n",
    "    def step(self, closure=None):\n",
    "\n",
    "        loss = None\n",
    "        if closure is not None:\n",
    "            loss = closure()\n",
    "\n",
    "        for group in self.param_groups:\n",
    "\n",
    "            for p in group['params']:\n",
    "                if p.grad is None:\n",
    "                    continue\n",
    "                grad = p.grad.data.float()\n",
    "                if grad.is_sparse:\n",
    "                    raise RuntimeError('RAdam does not support sparse gradients')\n",
    "\n",
    "                p_data_fp32 = p.data.float()\n",
    "\n",
    "                state = self.state[p]\n",
    "\n",
    "                if len(state) == 0:\n",
    "                    state['step'] = 0\n",
    "                    state['exp_avg'] = torch.zeros_like(p_data_fp32)\n",
    "                    state['exp_avg_sq'] = torch.zeros_like(p_data_fp32)\n",
    "                else:\n",
    "                    state['exp_avg'] = state['exp_avg'].type_as(p_data_fp32)\n",
    "                    state['exp_avg_sq'] = state['exp_avg_sq'].type_as(p_data_fp32)\n",
    "\n",
    "                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n",
    "                beta1, beta2 = group['betas']\n",
    "\n",
    "                exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n",
    "                exp_avg.mul_(beta1).add_(1 - beta1, grad)\n",
    "\n",
    "                state['step'] += 1\n",
    "                buffered = group['buffer'][int(state['step'] % 10)]\n",
    "                if state['step'] == buffered[0]:\n",
    "                    N_sma, step_size = buffered[1], buffered[2]\n",
    "                else:\n",
    "                    buffered[0] = state['step']\n",
    "                    beta2_t = beta2 ** state['step']\n",
    "                    N_sma_max = 2 / (1 - beta2) - 1\n",
    "                    N_sma = N_sma_max - 2 * state['step'] * beta2_t / (1 - beta2_t)\n",
    "                    buffered[1] = N_sma\n",
    "\n",
    "                    # more conservative since it's an approximated value\n",
    "                    if N_sma >= 5:\n",
    "                        step_size = math.sqrt((1 - beta2_t) * (N_sma - 4) / (N_sma_max - 4) * (N_sma - 2) / N_sma * N_sma_max / (N_sma_max - 2)) / (1 - beta1 ** state['step'])\n",
    "                    elif self.degenerated_to_sgd:\n",
    "                        step_size = 1.0 / (1 - beta1 ** state['step'])\n",
    "                    else:\n",
    "                        step_size = -1\n",
    "                    buffered[2] = step_size\n",
    "\n",
    "                # more conservative since it's an approximated value\n",
    "                if N_sma >= 5:\n",
    "                    if group['weight_decay'] != 0:\n",
    "                        p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)\n",
    "                    denom = exp_avg_sq.sqrt().add_(group['eps'])\n",
    "                    p_data_fp32.addcdiv_(-step_size * group['lr'], exp_avg, denom)\n",
    "                    p.data.copy_(p_data_fp32)\n",
    "                elif step_size > 0:\n",
    "                    if group['weight_decay'] != 0:\n",
    "                        p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)\n",
    "                    p_data_fp32.add_(-step_size * group['lr'], exp_avg)\n",
    "                    p.data.copy_(p_data_fp32)\n",
    "\n",
    "        return loss\n",
    "\n",
    "class PlainRAdam(Optimizer):\n",
    "\n",
    "    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0, degenerated_to_sgd=False):\n",
    "        if not 0.0 <= lr:\n",
    "            raise ValueError(\"Invalid learning rate: {}\".format(lr))\n",
    "        if not 0.0 <= eps:\n",
    "            raise ValueError(\"Invalid epsilon value: {}\".format(eps))\n",
    "        if not 0.0 <= betas[0] < 1.0:\n",
    "            raise ValueError(\"Invalid beta parameter at index 0: {}\".format(betas[0]))\n",
    "        if not 0.0 <= betas[1] < 1.0:\n",
    "            raise ValueError(\"Invalid beta parameter at index 1: {}\".format(betas[1]))\n",
    "                    \n",
    "        self.degenerated_to_sgd = degenerated_to_sgd\n",
    "        defaults = dict(lr=lr, betas=betas, eps=eps, weight_decay=weight_decay)\n",
    "\n",
    "        super(PlainRAdam, self).__init__(params, defaults)\n",
    "\n",
    "    def __setstate__(self, state):\n",
    "        super(PlainRAdam, self).__setstate__(state)\n",
    "\n",
    "    def step(self, closure=None):\n",
    "\n",
    "        loss = None\n",
    "        if closure is not None:\n",
    "            loss = closure()\n",
    "\n",
    "        for group in self.param_groups:\n",
    "\n",
    "            for p in group['params']:\n",
    "                if p.grad is None:\n",
    "                    continue\n",
    "                grad = p.grad.data.float()\n",
    "                if grad.is_sparse:\n",
    "                    raise RuntimeError('RAdam does not support sparse gradients')\n",
    "\n",
    "                p_data_fp32 = p.data.float()\n",
    "\n",
    "                state = self.state[p]\n",
    "\n",
    "                if len(state) == 0:\n",
    "                    state['step'] = 0\n",
    "                    state['exp_avg'] = torch.zeros_like(p_data_fp32)\n",
    "                    state['exp_avg_sq'] = torch.zeros_like(p_data_fp32)\n",
    "                else:\n",
    "                    state['exp_avg'] = state['exp_avg'].type_as(p_data_fp32)\n",
    "                    state['exp_avg_sq'] = state['exp_avg_sq'].type_as(p_data_fp32)\n",
    "\n",
    "                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n",
    "                beta1, beta2 = group['betas']\n",
    "\n",
    "                exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n",
    "                exp_avg.mul_(beta1).add_(1 - beta1, grad)\n",
    "\n",
    "                state['step'] += 1\n",
    "                beta2_t = beta2 ** state['step']\n",
    "                N_sma_max = 2 / (1 - beta2) - 1\n",
    "                N_sma = N_sma_max - 2 * state['step'] * beta2_t / (1 - beta2_t)\n",
    "\n",
    "\n",
    "                # more conservative since it's an approximated value\n",
    "                if N_sma >= 5:\n",
    "                    if group['weight_decay'] != 0:\n",
    "                        p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)\n",
    "                    step_size = group['lr'] * math.sqrt((1 - beta2_t) * (N_sma - 4) / (N_sma_max - 4) * (N_sma - 2) / N_sma * N_sma_max / (N_sma_max - 2)) / (1 - beta1 ** state['step'])\n",
    "                    denom = exp_avg_sq.sqrt().add_(group['eps'])\n",
    "                    p_data_fp32.addcdiv_(-step_size, exp_avg, denom)\n",
    "                    p.data.copy_(p_data_fp32)\n",
    "                elif self.degenerated_to_sgd:\n",
    "                    if group['weight_decay'] != 0:\n",
    "                        p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)\n",
    "                    step_size = group['lr'] / (1 - beta1 ** state['step'])\n",
    "                    p_data_fp32.add_(-step_size, exp_avg)\n",
    "                    p.data.copy_(p_data_fp32)\n",
    "\n",
    "        return loss\n",
    "\n",
    "\n",
    "class AdamW(Optimizer):\n",
    "\n",
    "    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weight_decay=0, warmup = 0):\n",
    "        if not 0.0 <= lr:\n",
    "            raise ValueError(\"Invalid learning rate: {}\".format(lr))\n",
    "        if not 0.0 <= eps:\n",
    "            raise ValueError(\"Invalid epsilon value: {}\".format(eps))\n",
    "        if not 0.0 <= betas[0] < 1.0:\n",
    "            raise ValueError(\"Invalid beta parameter at index 0: {}\".format(betas[0]))\n",
    "        if not 0.0 <= betas[1] < 1.0:\n",
    "            raise ValueError(\"Invalid beta parameter at index 1: {}\".format(betas[1]))\n",
    "        \n",
    "        defaults = dict(lr=lr, betas=betas, eps=eps,\n",
    "                        weight_decay=weight_decay, warmup = warmup)\n",
    "        super(AdamW, self).__init__(params, defaults)\n",
    "\n",
    "    def __setstate__(self, state):\n",
    "        super(AdamW, self).__setstate__(state)\n",
    "\n",
    "    def step(self, closure=None):\n",
    "        loss = None\n",
    "        if closure is not None:\n",
    "            loss = closure()\n",
    "\n",
    "        for group in self.param_groups:\n",
    "\n",
    "            for p in group['params']:\n",
    "                if p.grad is None:\n",
    "                    continue\n",
    "                grad = p.grad.data.float()\n",
    "                if grad.is_sparse:\n",
    "                    raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\n",
    "\n",
    "                p_data_fp32 = p.data.float()\n",
    "\n",
    "                state = self.state[p]\n",
    "\n",
    "                if len(state) == 0:\n",
    "                    state['step'] = 0\n",
    "                    state['exp_avg'] = torch.zeros_like(p_data_fp32)\n",
    "                    state['exp_avg_sq'] = torch.zeros_like(p_data_fp32)\n",
    "                else:\n",
    "                    state['exp_avg'] = state['exp_avg'].type_as(p_data_fp32)\n",
    "                    state['exp_avg_sq'] = state['exp_avg_sq'].type_as(p_data_fp32)\n",
    "\n",
    "                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n",
    "                beta1, beta2 = group['betas']\n",
    "\n",
    "                state['step'] += 1\n",
    "\n",
    "                exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n",
    "                exp_avg.mul_(beta1).add_(1 - beta1, grad)\n",
    "\n",
    "                denom = exp_avg_sq.sqrt().add_(group['eps'])\n",
    "                bias_correction1 = 1 - beta1 ** state['step']\n",
    "                bias_correction2 = 1 - beta2 ** state['step']\n",
    "                \n",
    "                if group['warmup'] > state['step']:\n",
    "                    scheduled_lr = 1e-8 + state['step'] * group['lr'] / group['warmup']\n",
    "                else:\n",
    "                    scheduled_lr = group['lr']\n",
    "\n",
    "                step_size = scheduled_lr * math.sqrt(bias_correction2) / bias_correction1\n",
    "                \n",
    "                if group['weight_decay'] != 0:\n",
    "                    p_data_fp32.add_(-group['weight_decay'] * scheduled_lr, p_data_fp32)\n",
    "\n",
    "                p_data_fp32.addcdiv_(-step_size, exp_avg, denom)\n",
    "\n",
    "                p.data.copy_(p_data_fp32)\n",
    "\n",
    "        return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dump to cpu\n"
     ]
    }
   ],
   "source": [
    "model = MTALSTM(hidden_dim=hidden_dim, embed_dim=embedding_dim, num_keywords=num_keywords, \n",
    "                num_layers=num_layers, num_labels=len(vocab), weight=word_vec, bidirectional=bidirectional)\n",
    "# optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)\n",
    "# optimizer = optim.Adam(model.parameters(), lr=lr)\n",
    "\n",
    "# from radam import RAdam\n",
    "optimizer = RAdam(model.parameters(), lr=lr)\n",
    "lr_scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.4, patience=2, min_lr=1e-7, verbose=True)\n",
    "# optimizer = optim.Adadelta(model.parameters(), lr=lr)\n",
    "if use_gpu:\n",
    "#     model = nn.DataParallel(model)\n",
    "#     model = model.to(device)\n",
    "    model = model.to(device)\n",
    "    print(f\"Dump to {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MTALSTM(\n",
       "  (embedding): Embedding(189613, 100)\n",
       "  (Uf): Linear(in_features=500, out_features=5, bias=False)\n",
       "  (decoder): AttentionDecoder(\n",
       "    (attention): Attention(\n",
       "      (Ua): Linear(in_features=100, out_features=512, bias=False)\n",
       "      (Wa): Linear(in_features=512, out_features=512, bias=False)\n",
       "      (va): Linear(in_features=512, out_features=1, bias=True)\n",
       "    )\n",
       "    (rnn): LSTM(200, 512, num_layers=2, dropout=0.5)\n",
       "  )\n",
       "  (adaptiveSoftmax): AdaptiveLogSoftmaxWithLoss(\n",
       "    (head): Linear(in_features=512, out_features=9483, bias=False)\n",
       "    (tail): ModuleList(\n",
       "      (0): Sequential(\n",
       "        (0): Linear(in_features=512, out_features=128, bias=False)\n",
       "        (1): Linear(in_features=128, out_features=28443, bias=False)\n",
       "      )\n",
       "      (1): Sequential(\n",
       "        (0): Linear(in_features=512, out_features=32, bias=False)\n",
       "        (1): Linear(in_features=32, out_features=151689, bias=False)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def params_init_uniform(m):\n",
    "    if type(m) == nn.Linear:\n",
    "        y = 0.04\n",
    "        nn.init.uniform_(m.weight, -y, y)\n",
    "        \n",
    "model.apply(params_init_uniform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load previous checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading previous status (ver.small_45)...\n",
      "Load successfully\n"
     ]
    }
   ],
   "source": [
    "version_name = args['checkpoint_version_name']      ### TODO\n",
    "version_epoch_num = args['checkpoint_epoch']      ### TODO\n",
    "Type = args['checkpoint_type']          ### TODO\n",
    "# Type = 'best'\n",
    "\n",
    "def check_point_path(obj_name, save_folder, Type, version_name, epoch_num):\n",
    "    return f'{save_folder}/{version_name}_{epoch_num}_{Type}_{obj_name}.pt'\n",
    "\n",
    "# model_check_point = '%s/model_%s_%d.pk' % (save_folder, Type, version_num)\n",
    "# optim_check_point = '%s/optim_%s_%d.pkl' % (save_folder, Type, version_num)\n",
    "# loss_check_point = '%s/loss_%s_%d.pkl' % (save_folder, Type, version_num)\n",
    "# epoch_check_point = '%s/epoch_%s_%d.pkl' % (save_folder, Type, version_num)\n",
    "# bleu_check_point = '%s/bleu_%s_%d.pkl' % (save_folder, Type, version_num)\n",
    "\n",
    "model_check_point = check_point_path('model', save_folder, Type, version_name, version_epoch_num)\n",
    "optim_check_point = check_point_path('optim', save_folder, Type, version_name, version_epoch_num)\n",
    "loss_check_point = check_point_path('loss', save_folder, Type, version_name, version_epoch_num)\n",
    "epoch_check_point = check_point_path('epoch', save_folder, Type, version_name, version_epoch_num)\n",
    "bleu_check_point = check_point_path('bleu', save_folder, Type, version_name, version_epoch_num)\n",
    "\n",
    "loss_values = []\n",
    "epoch_values = []\n",
    "bleu_values = []\n",
    "\n",
    "if os.path.isfile(model_check_point):\n",
    "    print(f'Loading previous status (ver.{version_name}_{version_epoch_num})...')\n",
    "    model.load_state_dict(torch.load(model_check_point, map_location='cpu'))\n",
    "    model = model.to(device)\n",
    "    optimizer.load_state_dict(torch.load(optim_check_point))\n",
    "    lr_scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.4, patience=2, min_lr=1e-7, verbose=True)\n",
    "    loss_values = torch.load(loss_check_point)\n",
    "    epoch_values = torch.load(epoch_check_point)\n",
    "    bleu_values = torch.load(bleu_check_point)\n",
    "    print('Load successfully')\n",
    "else:\n",
    "    print(f\"ver.{version_name}_{version_epoch_num} doesn't exist\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = 现在 未来 梦想 科学 文化\n",
      "output = <BOS> 这 是 我 的 学校 ， 是 祖国 ， 我 真 希望 对 我 的 希望 ， 在 我 的 家乡 — — 中国 梦 。 我 也 像 一个 “ 隐形 ” ， 因为 我 是 一名 科学家 的 梦想 ， 我 更 庆幸 我 的 视野 之 旅 ！\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-23-54bdfb19faf5>:15: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_yticklabels([''] + input_sentence.split(' '), fontproperties=fontprop, fontsize=10)\n",
      "<ipython-input-23-54bdfb19faf5>:16: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_xticklabels([''] + output_words, fontproperties=fontprop, fontsize=10, rotation=45)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1872x180 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluateAndShowAttention(['现在', '未来', '梦想', '科学', '文化'], method='beam_search', is_sample=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uf.weight Parameter containing:\n",
      "tensor([[-0.0411, -0.0628,  0.1448,  ...,  0.0119,  0.0138, -0.0233],\n",
      "        [-0.0109, -0.0394, -0.1695,  ...,  0.0130, -0.0101,  0.0497],\n",
      "        [-0.0218, -0.0427,  0.0306,  ..., -0.0388, -0.0917, -0.0111],\n",
      "        [-0.0973,  0.0509, -0.0956,  ...,  0.1699,  0.0793,  0.0927],\n",
      "        [-0.0152,  0.0195, -0.0728,  ...,  0.0160, -0.0602,  0.2743]],\n",
      "       requires_grad=True)\n",
      "decoder.attention.Ua.weight Parameter containing:\n",
      "tensor([[-0.0048,  0.0455, -0.0227,  ..., -0.0078, -0.0021,  0.0086],\n",
      "        [ 0.0109,  0.0187, -0.0281,  ...,  0.0328,  0.0062,  0.0337],\n",
      "        [-0.0499,  0.0123, -0.0218,  ...,  0.0808,  0.0644,  0.0982],\n",
      "        ...,\n",
      "        [ 0.0503, -0.0111, -0.0454,  ...,  0.0172, -0.0555, -0.0233],\n",
      "        [-0.0803,  0.0741, -0.0429,  ...,  0.0432,  0.0719,  0.0737],\n",
      "        [-0.0322, -0.0293,  0.0256,  ...,  0.0198,  0.0408,  0.0479]],\n",
      "       requires_grad=True)\n",
      "decoder.attention.Wa.weight Parameter containing:\n",
      "tensor([[-0.0425, -0.1076,  0.0468,  ..., -0.0558,  0.0578,  0.0574],\n",
      "        [ 0.0031,  0.0338,  0.0089,  ...,  0.0658, -0.0371,  0.0465],\n",
      "        [ 0.0245, -0.0282, -0.0470,  ..., -0.0571,  0.0139, -0.0294],\n",
      "        ...,\n",
      "        [-0.0562,  0.0725, -0.0227,  ...,  0.1727, -0.0243, -0.0268],\n",
      "        [ 0.0629, -0.0967, -0.0276,  ..., -0.0086,  0.0725,  0.0026],\n",
      "        [-0.0133,  0.0263, -0.0502,  ..., -0.0184, -0.0501, -0.0126]],\n",
      "       requires_grad=True)\n",
      "decoder.attention.va.weight Parameter containing:\n",
      "tensor([[ 0.1424, -0.1713, -0.0850,  0.1890, -0.1186, -0.1143,  0.1774, -0.1910,\n",
      "          0.0928, -0.1111,  0.1948, -0.1219, -0.1647,  0.1174, -0.0494, -0.1726,\n",
      "         -0.0948,  0.1087,  0.1428, -0.1023, -0.1092, -0.1104,  0.1367,  0.0071,\n",
      "         -0.1129,  0.1326, -0.1318, -0.0162, -0.1699, -0.1215, -0.1313, -0.1256,\n",
      "          0.0249,  0.1230,  0.0662,  0.1791,  0.2062,  0.1272, -0.0884,  0.1047,\n",
      "          0.1009, -0.1112,  0.1213,  0.1237, -0.1584, -0.0044,  0.1197, -0.0420,\n",
      "         -0.0876, -0.1094, -0.0673,  0.1635, -0.1300,  0.1273, -0.1183, -0.1233,\n",
      "          0.0240,  0.1826, -0.0568,  0.0041, -0.1040,  0.1527,  0.1397,  0.1038,\n",
      "         -0.0106, -0.0167, -0.1895, -0.1778,  0.0877,  0.1226, -0.0235,  0.1148,\n",
      "         -0.1124,  0.0717,  0.0072, -0.1754,  0.1153, -0.0947, -0.0087,  0.1921,\n",
      "          0.0371,  0.1207,  0.1265, -0.0474, -0.0757, -0.1073, -0.0992,  0.0197,\n",
      "          0.0777,  0.1455,  0.1169,  0.0033,  0.0015, -0.0745,  0.1236,  0.1107,\n",
      "         -0.0338, -0.0927,  0.1298, -0.1005, -0.1616, -0.1439,  0.1208, -0.1011,\n",
      "          0.0020,  0.0994, -0.0824, -0.1104, -0.0137,  0.0909, -0.2214, -0.1209,\n",
      "         -0.0960,  0.0927,  0.0475,  0.0964, -0.1769, -0.0753,  0.1107,  0.1019,\n",
      "          0.1271, -0.1669, -0.1394,  0.0541,  0.1266,  0.0206,  0.0713, -0.1888,\n",
      "          0.1189, -0.0765, -0.1195,  0.1135, -0.1827,  0.1579,  0.0465, -0.1902,\n",
      "          0.1380, -0.2032, -0.1363,  0.0672,  0.0366, -0.0295, -0.1113,  0.1672,\n",
      "         -0.0700,  0.1182,  0.1907, -0.0857,  0.0228, -0.2002,  0.1442,  0.0843,\n",
      "          0.0067,  0.1717,  0.1712,  0.0955, -0.1708,  0.1017, -0.1090, -0.1431,\n",
      "          0.0059,  0.1023,  0.0989,  0.1284,  0.1974, -0.1273,  0.1263,  0.1395,\n",
      "         -0.1362, -0.1907, -0.1381, -0.1217,  0.0800, -0.1480,  0.0083,  0.0992,\n",
      "          0.0906, -0.1157, -0.1714,  0.1712, -0.1478,  0.1396,  0.1070, -0.1411,\n",
      "          0.0004,  0.1792,  0.0900,  0.0254,  0.1516,  0.0963, -0.1158, -0.0200,\n",
      "         -0.0260,  0.1223, -0.2067, -0.1783,  0.1194,  0.1089, -0.0245,  0.1362,\n",
      "         -0.0113,  0.0022,  0.0011,  0.1544, -0.1393,  0.1195,  0.1300, -0.0524,\n",
      "         -0.0961, -0.0346, -0.1792,  0.0328, -0.1281, -0.0691, -0.0966,  0.0100,\n",
      "          0.0011,  0.0160, -0.0074,  0.1875, -0.1006,  0.0538, -0.0936,  0.1328,\n",
      "         -0.0627, -0.0809, -0.1044,  0.1244,  0.0575,  0.0480, -0.1665,  0.1320,\n",
      "          0.0971,  0.1164,  0.0235, -0.1997, -0.1111,  0.0866, -0.1771,  0.0144,\n",
      "         -0.0058,  0.1435, -0.0828, -0.0917,  0.1761,  0.0982, -0.1880, -0.1299,\n",
      "         -0.0717, -0.0533, -0.1228,  0.1345,  0.0254, -0.0873, -0.0339,  0.1274,\n",
      "         -0.1468,  0.0943,  0.1946,  0.1226,  0.1119, -0.1964,  0.1106,  0.1310,\n",
      "         -0.1952,  0.1863,  0.1285,  0.1638,  0.1528, -0.1620,  0.1539, -0.1439,\n",
      "         -0.1101, -0.1016, -0.0957,  0.0809, -0.1832,  0.1034, -0.1230,  0.2005,\n",
      "          0.0973,  0.0277, -0.1597,  0.0843, -0.1422,  0.1130, -0.1640, -0.0988,\n",
      "          0.0074,  0.2012,  0.1897,  0.0294, -0.2082, -0.0957,  0.1756,  0.1336,\n",
      "          0.1938,  0.0832, -0.1975, -0.1184,  0.1169, -0.0051,  0.1092,  0.1580,\n",
      "          0.1366, -0.1007,  0.1570, -0.0986,  0.0728,  0.1892,  0.0987, -0.2080,\n",
      "         -0.0070, -0.0020,  0.1711, -0.1184, -0.0824, -0.1207,  0.1432, -0.0564,\n",
      "         -0.2074,  0.1010,  0.0928,  0.0479,  0.0245,  0.0012,  0.0253, -0.0535,\n",
      "          0.1151, -0.0933, -0.1225,  0.1996, -0.1663,  0.1980,  0.0823, -0.2025,\n",
      "          0.0174, -0.2144, -0.2025, -0.1129,  0.0946,  0.1895,  0.1746,  0.0724,\n",
      "          0.1931, -0.1427, -0.1076, -0.1048, -0.1371, -0.1200,  0.1522, -0.0898,\n",
      "         -0.0585,  0.0877, -0.0879,  0.1304,  0.1540, -0.1239,  0.1159,  0.0770,\n",
      "          0.1711,  0.0877,  0.1086, -0.1208, -0.1092, -0.0985, -0.1720,  0.1236,\n",
      "         -0.1864, -0.1697, -0.1334,  0.1527, -0.0386,  0.1488, -0.0610,  0.0237,\n",
      "         -0.0003,  0.1499,  0.1838, -0.1338,  0.2064,  0.1583,  0.0967, -0.1737,\n",
      "         -0.0704,  0.1342,  0.0146, -0.1463, -0.0730, -0.1196, -0.1070,  0.1556,\n",
      "         -0.0104, -0.1589,  0.0987, -0.0946,  0.0848, -0.1528, -0.1234,  0.1532,\n",
      "         -0.0896, -0.1800, -0.1569,  0.0773,  0.1418, -0.1544, -0.1280,  0.0861,\n",
      "          0.1264,  0.1696, -0.1778,  0.1244, -0.0133,  0.0631,  0.0978, -0.0600,\n",
      "          0.0957,  0.1016, -0.0841,  0.0856, -0.0284,  0.1646, -0.1485, -0.0803,\n",
      "         -0.1534,  0.0569,  0.1996,  0.1268,  0.1877,  0.1466, -0.1679,  0.0326,\n",
      "          0.1178, -0.0823, -0.1135,  0.0919,  0.0725, -0.1451,  0.0112, -0.0835,\n",
      "          0.1468, -0.1281,  0.1237,  0.0888,  0.0047,  0.0390, -0.1121,  0.1004,\n",
      "          0.0566,  0.1030, -0.2129,  0.0108,  0.1731,  0.1854,  0.1710,  0.0209,\n",
      "         -0.1096,  0.1167, -0.0940, -0.0307,  0.1783, -0.0642, -0.1059, -0.1815,\n",
      "          0.1593,  0.1053, -0.1740, -0.1031,  0.0749,  0.1010,  0.1706, -0.1162,\n",
      "          0.1226, -0.0424,  0.1940, -0.1224,  0.1458, -0.1158,  0.0939, -0.1947,\n",
      "         -0.0005, -0.0972, -0.1206,  0.0955, -0.1405, -0.1284,  0.1060, -0.1901,\n",
      "          0.0675, -0.1766, -0.1174, -0.0698,  0.1601,  0.1232,  0.0554, -0.1393,\n",
      "         -0.1510, -0.1020, -0.0479,  0.1601, -0.1604,  0.1222, -0.1237,  0.0327,\n",
      "         -0.1210,  0.1163,  0.1023, -0.1490,  0.2053,  0.0848, -0.0915, -0.1722]],\n",
      "       requires_grad=True)\n",
      "decoder.attention.va.bias Parameter containing:\n",
      "tensor([0.1515], requires_grad=True)\n",
      "decoder.rnn.weight_ih_l0 Parameter containing:\n",
      "tensor([[-0.0427, -0.0324,  0.1612,  ..., -0.0951,  0.0968, -0.1551],\n",
      "        [-0.0834,  0.0370, -0.1473,  ..., -0.0792,  0.0386, -0.1513],\n",
      "        [-0.2791, -0.1117, -0.0798,  ...,  0.1269, -0.1023, -0.0479],\n",
      "        ...,\n",
      "        [ 0.1643,  0.5288, -0.0555,  ..., -0.0659, -0.0237,  0.0734],\n",
      "        [-0.3364, -0.1498,  0.1163,  ..., -0.0225,  0.0962,  0.0535],\n",
      "        [-0.2794, -0.5481,  0.3051,  ..., -0.0030,  0.0368, -0.1527]],\n",
      "       requires_grad=True)\n",
      "decoder.rnn.weight_hh_l0 Parameter containing:\n",
      "tensor([[-0.0246,  0.0384, -0.1997,  ..., -0.0782, -0.0363, -0.0007],\n",
      "        [ 0.0524,  0.1236, -0.0066,  ..., -0.1049,  0.0821, -0.0484],\n",
      "        [-0.0450,  0.1356,  0.1194,  ..., -0.0725,  0.0506, -0.0570],\n",
      "        ...,\n",
      "        [ 0.1995,  0.0425, -0.0852,  ..., -0.0431, -0.0855, -0.0102],\n",
      "        [-0.0006,  0.0059, -0.0700,  ...,  0.1070, -0.0572, -0.2465],\n",
      "        [ 0.0216,  0.0441, -0.0521,  ..., -0.1208, -0.0933, -0.1024]],\n",
      "       requires_grad=True)\n",
      "decoder.rnn.bias_ih_l0 Parameter containing:\n",
      "tensor([0.1019, 0.0466, 0.0695,  ..., 0.0470, 0.0792, 0.0668],\n",
      "       requires_grad=True)\n",
      "decoder.rnn.bias_hh_l0 Parameter containing:\n",
      "tensor([ 0.1243,  0.0604,  0.1482,  ...,  0.0736,  0.1141, -0.0205],\n",
      "       requires_grad=True)\n",
      "decoder.rnn.weight_ih_l1 Parameter containing:\n",
      "tensor([[ 1.3528e-01,  9.5500e-03,  1.0236e-01,  ...,  7.8569e-02,\n",
      "          6.2730e-02,  1.5021e-01],\n",
      "        [-1.5589e-01,  4.7724e-02,  1.7251e-01,  ...,  1.3380e-02,\n",
      "          3.0688e-02, -1.3992e-01],\n",
      "        [-3.9483e-02,  1.5981e-01, -9.9046e-03,  ...,  7.2530e-02,\n",
      "          5.4445e-02,  3.5786e-02],\n",
      "        ...,\n",
      "        [-9.0055e-02,  1.7073e-01, -1.6213e-01,  ..., -2.5892e-01,\n",
      "         -1.5377e-02,  3.3830e-03],\n",
      "        [-1.2651e-01, -8.8891e-03,  1.5330e-01,  ...,  2.9422e-02,\n",
      "          1.8992e-01, -1.4910e-01],\n",
      "        [-1.2115e-04,  1.1911e-01, -6.7813e-02,  ..., -2.3290e-01,\n",
      "          2.2851e-01, -4.6630e-02]], requires_grad=True)\n",
      "decoder.rnn.weight_hh_l1 Parameter containing:\n",
      "tensor([[-1.3267e-01, -9.7699e-03, -6.3147e-03,  ...,  7.2645e-04,\n",
      "         -1.9433e-02,  2.5650e-02],\n",
      "        [ 3.8262e-02, -1.0443e-02,  9.6047e-04,  ...,  4.1833e-03,\n",
      "          2.0624e-03,  7.7691e-02],\n",
      "        [-5.4214e-02, -1.6529e-03,  6.8097e-02,  ..., -1.0559e-03,\n",
      "          3.5431e-03, -1.8290e-02],\n",
      "        ...,\n",
      "        [-1.4904e-01,  1.8474e-02, -6.6396e-02,  ..., -1.4956e-01,\n",
      "          1.6916e-01,  1.3875e-01],\n",
      "        [ 6.7489e-02, -2.6407e-02, -6.2470e-02,  ..., -9.3108e-02,\n",
      "         -3.4249e-02, -1.5553e-01],\n",
      "        [ 2.3261e-02,  9.5587e-04, -1.1163e-01,  ...,  7.3634e-02,\n",
      "          6.1048e-05,  1.3414e-02]], requires_grad=True)\n",
      "decoder.rnn.bias_ih_l1 Parameter containing:\n",
      "tensor([0.0118, 0.0046, 0.1485,  ..., 0.0898, 0.1137, 0.0343],\n",
      "       requires_grad=True)\n",
      "decoder.rnn.bias_hh_l1 Parameter containing:\n",
      "tensor([ 0.0701, -0.0153,  0.0792,  ...,  0.0853,  0.0777,  0.0524],\n",
      "       requires_grad=True)\n",
      "adaptiveSoftmax.head.weight Parameter containing:\n",
      "tensor([[ 0.4681, -0.0791,  0.1753,  ..., -0.1000,  0.2427,  0.0693],\n",
      "        [ 0.1290,  0.0784, -0.0890,  ..., -0.0640, -0.0813, -0.1625],\n",
      "        [ 0.1095,  0.0576, -0.1148,  ..., -0.0254,  0.0323, -0.1307],\n",
      "        ...,\n",
      "        [ 0.1775,  0.0523, -0.1522,  ..., -0.2547,  0.2112,  0.2872],\n",
      "        [-0.0951, -0.0087,  0.1350,  ...,  0.0469,  0.1936,  0.0155],\n",
      "        [-0.0409, -0.0277,  0.1849,  ...,  0.0731,  0.2049,  0.0034]],\n",
      "       requires_grad=True)\n",
      "adaptiveSoftmax.tail.0.0.weight Parameter containing:\n",
      "tensor([[-0.1998,  0.9995, -0.0840,  ..., -0.0982,  0.0658,  0.0159],\n",
      "        [ 0.0748, -0.1536, -0.1363,  ...,  0.0764, -0.0580,  0.0140],\n",
      "        [ 0.1311,  0.4334, -0.1041,  ...,  0.1662, -0.0793,  0.0681],\n",
      "        ...,\n",
      "        [ 0.0538,  0.4370, -0.1672,  ...,  0.0886, -0.0096, -0.0402],\n",
      "        [-0.1294, -0.2350, -0.2167,  ..., -0.0234, -0.0956,  0.1421],\n",
      "        [ 0.0948, -0.1085,  0.0267,  ...,  0.0057, -0.0546, -0.1431]],\n",
      "       requires_grad=True)\n",
      "adaptiveSoftmax.tail.0.1.weight Parameter containing:\n",
      "tensor([[ 0.0574, -0.0265, -0.0396,  ..., -0.1490,  0.0422, -0.0248],\n",
      "        [ 0.0300, -0.1441, -0.0080,  ...,  0.1255, -0.0950,  0.4116],\n",
      "        [-0.0149, -0.1008, -0.0135,  ...,  0.0576, -0.1763,  0.5155],\n",
      "        ...,\n",
      "        [ 0.0062, -0.2303, -0.0696,  ...,  0.0740, -0.0795, -0.0996],\n",
      "        [-0.0746, -0.0443, -0.0670,  ..., -0.0198, -0.1278,  0.2453],\n",
      "        [-0.0415, -0.2070, -0.0145,  ...,  0.0665, -0.1666,  0.3670]],\n",
      "       requires_grad=True)\n",
      "adaptiveSoftmax.tail.1.0.weight Parameter containing:\n",
      "tensor([[ 0.1804,  0.2311, -0.5405,  ..., -0.0394, -0.0190,  0.0035],\n",
      "        [ 0.1449,  0.9085, -0.2815,  ...,  0.1103,  0.0344, -0.1758],\n",
      "        [ 1.0034,  0.2736,  0.5237,  ...,  0.0357,  0.4751,  0.1807],\n",
      "        ...,\n",
      "        [-0.2250, -0.4215,  0.3049,  ...,  0.9575, -0.1680,  0.5071],\n",
      "        [ 0.1436,  0.5397, -0.1862,  ..., -0.4800, -0.1186,  0.0116],\n",
      "        [ 0.1339, -1.0087, -0.3834,  ..., -0.3544, -0.2522, -0.0125]],\n",
      "       requires_grad=True)\n",
      "adaptiveSoftmax.tail.1.1.weight Parameter containing:\n",
      "tensor([[ 0.1146,  0.0282, -0.1030,  ...,  0.1087, -0.0921, -0.0771],\n",
      "        [ 0.0843,  0.0159, -0.1251,  ..., -0.0139,  0.0260, -0.1098],\n",
      "        [ 0.0516,  0.0726, -0.1152,  ...,  0.0343,  0.0996, -0.1123],\n",
      "        ...,\n",
      "        [ 0.0883,  0.0350, -0.1508,  ...,  0.0056,  0.0105, -0.1332],\n",
      "        [ 0.0898,  0.0369, -0.1417,  ...,  0.0154,  0.0287, -0.1275],\n",
      "        [ 0.0293, -0.0218, -0.0246,  ..., -0.0903,  0.0064, -0.1057]],\n",
      "       requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "def isnan(x):\n",
    "    return x != x\n",
    "\n",
    "for name, p in model.named_parameters():\n",
    "#     if p.grad is None:\n",
    "#         continue\n",
    "    if p.requires_grad:\n",
    "        print(name, p)\n",
    "#         p.register_hook(lambda grad: torch.clamp(grad, -clip_value, clip_value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decay_lr(optimizer, epoch, factor=0.1, lr_decay_epoch=60):\n",
    "    if epoch % lr_decay_epoch == 0:\n",
    "        for param_group in optimizer.param_groups:\n",
    "            param_group['lr'] = param_group['lr'] * factor\n",
    "        print('lr decayed to %.4f' % optimizer.param_group[0]['lr'])\n",
    "    return optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "since = time.time()\n",
    "autograd.set_detect_anomaly(False)\n",
    "prev_epoch = 0 if not epoch_values else epoch_values[-1]\n",
    "best_bleu = 0 if not bleu_values else max(bleu_values)\n",
    "\n",
    "\n",
    "def save_check_point(model, optimizer, loss_values, epoch_values, bleu_values, save_folder, Type, version_name, epoch_num):\n",
    "    model_check_point = check_point_path('model', save_folder, Type, version_name, epoch_num)\n",
    "    optim_check_point = check_point_path('optim', save_folder, Type, version_name, epoch_num)\n",
    "    loss_check_point = check_point_path('loss', save_folder, Type, version_name, epoch_num)\n",
    "    epoch_check_point = check_point_path('epoch', save_folder, Type, version_name, epoch_num)\n",
    "    bleu_check_point = check_point_path('bleu', save_folder, Type, version_name, epoch_num)\n",
    "    \n",
    "    torch.save(model.state_dict(), model_check_point)\n",
    "    torch.save(optimizer.state_dict(), optim_check_point)\n",
    "    torch.save(loss_values, loss_check_point)\n",
    "    torch.save(epoch_values, epoch_check_point)\n",
    "    torch.save(bleu_values, bleu_check_point)\n",
    "\n",
    "\n",
    "for epoch in range(num_epoch - prev_epoch):\n",
    "    epoch += prev_epoch\n",
    "    start = time.time()\n",
    "    num, total_loss = 0, 0\n",
    "#     optimizer = decay_lr(optimizer=optimizer, epoch=epoch+1)\n",
    "    topics_indice, corpus_indice = shuffleData(topics_indice, corpus_indice) # shuffle data at every epoch\n",
    "    data = data_iterator(corpus_indice, topics_indice, batch_size, max(length) + 1)\n",
    "    hidden = model.init_hidden(batch_size=batch_size)\n",
    "    weight = torch.ones(len(vocab))\n",
    "    weight[0] = 0\n",
    "    num_iter = len(corpus_indice) // batch_size\n",
    "    for X, Y, mask, topics in tqdm(data, total=num_iter):\n",
    "        num += 1\n",
    "#         hidden.detach_()\n",
    "        if use_gpu:\n",
    "            X = X.to(device)\n",
    "            Y = Y.to(device)\n",
    "            mask = mask.to(device)\n",
    "            topics = topics.to(device)\n",
    "#             hidden = hidden.to(device)\n",
    "#             hidden[0].to(device)\n",
    "#             hidden[1].to(device)\n",
    "            loss_function = loss_function.to(device)\n",
    "            weight = weight.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        # init hidden layer\n",
    "#         hidden = model.init_hidden(num_layers, batch_size, hidden_dim)\n",
    "        coverage_vector = model.init_coverage_vector(batch_size, num_keywords)\n",
    "        init_output = torch.zeros(batch_size, hidden_dim).to(device)\n",
    "        # inputs, topics, output, hidden=None, mask=None, target=None, coverage_vector=None, seq_length=None):\n",
    "        output, _, hidden, _, _ = model(inputs=X, topics=topics, output=init_output, hidden=hidden, mask=mask, target=Y, coverage_vector=coverage_vector)\n",
    "#         output, hidden = model(X, topics)\n",
    "        hidden[0].detach_()\n",
    "        hidden[1].detach_()\n",
    "        \n",
    "        loss = (-output.output).reshape((-1, batch_size)).t() * mask\n",
    "#         loss = loss.sum(dim=1)\n",
    "        loss = loss.sum(dim=1) / mask.sum(dim=1)\n",
    "        loss = loss.mean()\n",
    "        loss.backward()\n",
    "        \n",
    "        norm = 0.0\n",
    "#         norm = nn.utils.clip_grad_norm_(model.parameters(), 10)\n",
    "        nn.utils.clip_grad_value_(model.parameters(), 1)\n",
    "            \n",
    "        optimizer.step()\n",
    "        total_loss += float(loss.item())\n",
    "        \n",
    "        if np.isnan(total_loss):\n",
    "            for name, p in model.named_parameters():\n",
    "                if p.grad is None:\n",
    "                    continue \n",
    "                print(name, p)\n",
    "            assert False, \"Gradient explode\"\n",
    "    \n",
    "    one_iter_loss = np.mean(total_loss)\n",
    "    lr_scheduler.step(one_iter_loss)\n",
    "#     print(\"One iteration loss {:.3f}\".format(one_iter_loss))\n",
    "    \n",
    "    # validation\n",
    "    bleu_score = 0\n",
    "    num_test = 500\n",
    "    bleu_score = evaluate_bleu(model, topics_test, corpus_test, num_test=num_test, method='predict_rnn', is_sample=True)\n",
    "    \n",
    "    bleu_values.append(bleu_score)\n",
    "    loss_values.append(total_loss / num)\n",
    "    epoch_values.append(epoch+1)\n",
    "    \n",
    "    # save checkpoint\n",
    "    if ((epoch + 1) % check_point == 0) or (epoch == (num_epoch - 1)) or epoch+1 > (num_epoch*0.9) or bleu_score > 4:\n",
    "        # model_check_point = '%s/model_trainable_%d.pk' % (save_folder, epoch+1)\n",
    "        # optim_check_point = '%s/optim_trainable_%d.pkl' % (save_folder, epoch+1)\n",
    "        # loss_check_point = '%s/loss_trainable_%d.pkl' % (save_folder, epoch+1)\n",
    "        # epoch_check_point = '%s/epoch_trainable_%d.pkl' % (save_folder, epoch+1)\n",
    "        # bleu_check_point = '%s/bleu_trainable_%d.pkl' % (save_folder, epoch+1)\n",
    "        # \n",
    "        # torch.save(model.state_dict(), model_check_point)\n",
    "        # torch.save(optimizer.state_dict(), optim_check_point)\n",
    "        # torch.save(loss_values, loss_check_point)\n",
    "        # torch.save(epoch_values, epoch_check_point)\n",
    "        # torch.save(bleu_values, bleu_check_point)\n",
    "        save_check_point(model, optimizer, loss_values, epoch_values, bleu_values, save_folder, 'trainable', version_name, epoch+1)\n",
    "    \n",
    "    # save current best result\n",
    "    if bleu_score > best_bleu:\n",
    "        best_bleu = bleu_score\n",
    "        print('current best bleu: %.4f' % best_bleu)\n",
    "        \n",
    "        # model_check_point = '%s/model_best_%d.pk' % (save_folder, epoch+1)\n",
    "        # optim_check_point = '%s/optim_best_%d.pkl' % (save_folder, epoch+1)\n",
    "        # loss_check_point = '%s/loss_best_%d.pkl' % (save_folder, epoch+1)\n",
    "        # epoch_check_point = '%s/epoch_best_%d.pkl' % (save_folder, epoch+1)\n",
    "        # bleu_check_point = '%s/bleu_best_%d.pkl' % (save_folder, epoch+1)\n",
    "        # \n",
    "        # torch.save(model.state_dict(), model_check_point)\n",
    "        # torch.save(optimizer.state_dict(), optim_check_point)\n",
    "        # torch.save(loss_values, loss_check_point)\n",
    "        # torch.save(epoch_values, epoch_check_point)\n",
    "        # torch.save(bleu_values, bleu_check_point)\n",
    "        save_check_point(model, optimizer, loss_values, epoch_values, bleu_values, save_folder, 'best', version_name, epoch+1)\n",
    "        \n",
    "    # calculate time\n",
    "    end = time.time()\n",
    "    s = end - since\n",
    "    h = math.floor(s / 3600)\n",
    "    m = s - h * 3600\n",
    "    m = math.floor(m / 60)\n",
    "    s -= (m * 60 + h * 3600)\n",
    "    \n",
    "    # verbose\n",
    "    if ((epoch + 1) % verbose == 0) or (epoch == (num_epoch - 1)):\n",
    "        print('epoch %d/%d, loss %.4f, norm %.4f, predict bleu: %.4f, time %.3fs, since %dh %dm %ds'\n",
    "              % (epoch + 1, num_epoch, total_loss / num, norm, bleu_score, end - start, h, m, s))\n",
    "        # 不 sample 全是逗号\n",
    "        evaluateAndShowAttention(['现在', '未来', '梦想', '科学', '文化'], method='beam_search', is_sample=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(epoch_values, loss_values, 'b')\n",
    "plt.title('loss vs. epoch')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(epoch_values, bleu_values, 'r')\n",
    "plt.title('bleu vs. epoch')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('bleu score')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/500 [00:00<?, ?it/s]/opt/conda/lib/python3.8/site-packages/nltk/translate/bleu_score.py:552: UserWarning: \n",
      "The hypothesis contains 0 counts of 2-gram overlaps.\n",
      "Therefore the BLEU score evaluates to 0, independently of\n",
      "how many N-gram overlaps of lower order it contains.\n",
      "Consider using lower n-gram order or use SmoothingFunction()\n",
      "  warnings.warn(_msg)\n",
      "/opt/conda/lib/python3.8/site-packages/nltk/translate/bleu_score.py:552: UserWarning: \n",
      "The hypothesis contains 0 counts of 3-gram overlaps.\n",
      "Therefore the BLEU score evaluates to 0, independently of\n",
      "how many N-gram overlaps of lower order it contains.\n",
      "Consider using lower n-gram order or use SmoothingFunction()\n",
      "  warnings.warn(_msg)\n",
      "/opt/conda/lib/python3.8/site-packages/nltk/translate/bleu_score.py:552: UserWarning: \n",
      "The hypothesis contains 0 counts of 4-gram overlaps.\n",
      "Therefore the BLEU score evaluates to 0, independently of\n",
      "how many N-gram overlaps of lower order it contains.\n",
      "Consider using lower n-gram order or use SmoothingFunction()\n",
      "  warnings.warn(_msg)\n",
      "100%|██████████| 500/500 [05:45<00:00,  1.45it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.1857788153882201"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_test = 5000\n",
    "bleu_score = evaluate_bleu(model, topics_test, corpus_test, num_test=num_test, method='predict_rnn', is_sample=True)\n",
    "bleu_score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test some samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = 妈妈 希望 长大 孩子 母爱\n",
      "output = <BOS> 是 一种 爱 ， 是 人世间 最 重要 的 财富 ； 是 一种 温暖 ， 是 一种 需要 世间 的 力量 。 爱 的 母亲 是 一种 深沉 的 力量 ； 母爱 是 一盏 明灯 的 夏日 ， 是 母亲 给 了 自己 温暖 的 温馨 ； 温暖 的 温馨 ， 让 我们 一起 分享 。\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-23-54bdfb19faf5>:15: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_yticklabels([''] + input_sentence.split(' '), fontproperties=fontprop, fontsize=10)\n",
      "<ipython-input-23-54bdfb19faf5>:16: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
      "  ax.set_xticklabels([''] + output_words, fontproperties=fontprop, fontsize=10, rotation=45)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2052x180 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = 现在 未来 梦想 科学 文化\n",
      "output = <BOS> 现在 ， 我 要 相信 自己 的 今天 ， 而 我 一定 会 好好学习 ， 相信 我 要 向 祖国 学习 ， 好好学习 现在 的 将来 ， 我 想 走进 祖国 的 未来 ， 让 祖国 的 未来 早日 更加 美好 富强 。 富强 ， 我 相信 会 有 中国 梦 。\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1908x180 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = 春天 来临 田野 聆听 小路\n",
      "output = <BOS> 我 的 家乡 是 一个 鸟语花香 的 季节 。 我 ， 在 成长 中 为 春天 渡 在 花海 的 冬天 里 尽情 着 成长 的 春天 。 春天 到 了 ， 天气 我 就要 到来 自己 的 到来 。 春天 ， 草长莺飞 抽出 好 来 了 ！\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABNEAAAC6CAYAAACA0Nv0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Il7ecAAAACXBIWXMAAAsTAAALEwEAmpwYAABJCUlEQVR4nO3dd5xcVfnH8c83C0mAkEAg9CpFpDcpgoA0KQoiKk1EFBARpAhi+1lRUQRBRCAiYMefiooKoiKCUhQQfigIiCBVkBJaElKf3x/PWTKsm92Z3Xt3Zzbf9+s1r93ZmX3mzC3nnvvcc85VRGBmZmZmZmZmZmbzN2q4C2BmZmZmZmZmZtbunEQzMzMzMzMzMzPrh5NoZmZmZmZmZmZm/XASzczMzMzMzMzMrB9OopmZmZmZmZmZmfXDSTQzMzMzMzMzM7N+OIlmZmZmZmZmZmbWDyfRzMzMzMzMzMzM+uEkmi0wJC0paYnhLoeZmZmZmVmVJK023GUwWxA4iWYLkuOATSSNknSEpGWGu0BmZmZmZmYDJWnN8utFkpaV5HN8sxp5B7MFgqT/AWZHxNXA14FFIuI/kiYOc9HMzMzMzMxaJukrwFcl7Q5cHxGPD3eZzEY6J9FsxJP0YWAD4G+SLgbWBm6Q9G1gHUmjh7N8ZmZmZmZmrZB0FrAs8EFgX+CdJZl2vqTtJE0a1gKajVBOotmIJulYYC7wbeCrwGbAH4FVgKWBWyNi5vCV0MzMzMzMrHmSzgSWjoj9IuJ24ItAF/Au4JvAw8BqkvYfvlKajUxOotmIJWk94AlgMvAm4AXgFOAW4O/ACsBl3VdpJGl4SmpmZmZmZtY/SV8CVomIg8rz0RFxD7AJEMAk4MmIuAl4haTFhq+0ZiOPImK4y1ApSYrypRp/twWLpHER8UK5G+f5wBjgAeD3wBLAasDWwK3AOsC7IuKp4SirmZmZmZlZf8p8zptExFXleVdEzJE0KiLmSloBOIkcibMmOaXN5hHx9PCV2mxkGRFJtJ7JspJtnxURM51IW/BIOg24ISIulfQ2ctjmr4A3AtcCewE7AocASwKXAdtGxAPDVGQzMzMzM7P5krQr8BBwd0mYdUXEnIbXuxNpiwATgHWB+yPi/mEqstmINCKSaN0krUOOBf8gOQ78kxExa3hLZUOpTLC5REQcUp4vHhHPSzqD7HG2KvAf4O3l+cnA+yPiruEqs5mZmZmZ2fxIehfwL+CfwAoRccN83ucOJGY16+g50SSNKz9XknQC8Hlge+BVZDJt9jAWz4aYpLOBo4ELy/PlmbeNfysi9gB+TQ7rXJXs6uwEmpmZmZmZtSVJBwFHkPOdfRm4WNJ6krp6vtcJNLP6LTTcBRgoSTsBu0v6JtmtdTRwbEQ8WOaHvywiwtn4BYOkrwAzgI2AqeXPqwPrSroIuAcgIo6X9DXge8BuTqCZmZmZmVk7kvRm4E7gOLIDwFPA1yPiDknjgeeGsXhmC6SO7IkmaUfgG8BVwIyIeAY4oyTQtgF2IzP1zsYvACR9FTgcOC0i/gZsL2lRYBdgZpkrYGFJ2wJExFHAlk6gmZmZmZlZO5J0NHAoMAt4N3mjtDuAPSVdAHxd0sblvR15Xm/WiTpuZ1N2M9sJOD0irgAeLC+9ovzcBfhORDwyHOWzoSXpTGBRYF9gUjmATAK+TiZSfyNpYfKOnLt23+I5Ih4flgKbmZmZmZn1QdJuwKPkOc3HgLeQc37fSY6+uY0cWXOSpNUjYu4wFdVsgdMxSbSSPOvuWfZP4J2SDgQulPQz4ApJnwK+A/yu+/02cpU5z26JiHdFxOXARODNEXEa8AhwIDCl3Fzi9cBrKD0Uzaw+vhqaepurpN112rorF0msZp22XUBnltnqVe5YaPZf2q2+KCNqHgVuAQ4GppM3Q/slsA1wDfBN4FZyGpujOrHNYdap2qrC6MdYeKmS+xZwEbAfcD8wGXgtsAewQ0Q8uaAO41xQkoeSPgYsFRHfbvjz2sBe5ff/BZ4Bzpb0DvIA9P6ImDakBe1H9/qStIak5Ya7PNY6SR07t2TVJJ1c7oi7wF8NlbQ1sE6nJHk6cd1JehWw2nCXoxWdVl906HbRcWXuJA3tliWGuSgtkXQcsFX5vZLzn4ZlMbqKeJ2sU5dFO9YXkrrK+cqd5M3yNgHuIjsCLAW8CHwVOA04lzyfn1ymrxnoZ64oaUz5fYE4lzQbjI5IoknaFTinzH11LrB0RHwVODAiPgpcEREPA5cCiw1jUYeNpFVg3hxwnVQBtnrlRNKXyLtr/qPHCerVwJsknUR2d94N+DOwOXB4RNxZUZGrtJykPYFzgIWhs9bdgk7SkcA7G54vsFe5JZ0FvDYini/Pxw5zkYaNpO2AtYDlgcWHuTj96sR1V5bxwcAnJK0maenhLlN/Oq2+6NDtouPK3GnKTbu2I9vlSw53eZpR2oXHAnt1J0wGm0jrvnFZmaf54jqSR5JeJ2li1XGrNhTLog7tWF+U48ShABExG7geeDOZNHsTeW7zVeCzwLMRsSdwVET8YxCfORp4NXCcpHHdN+Yb1BcxG+HaPokm6bXAV4Dvk0myp4CrJK0dEVPLTr6GpPcC7wJ+PXylHVqSxpWTh4WAYyVNLD2axrZrTzxJ20kaX8q6ahmSu6ekpk40lXfhfCV5d5qPASdKWrqcQC0LXAlsTPY6eyYivg58sN1uIiCpS9Ik4BfAqcCJwFPd684Hr44xFbgPQNLBwD7tNiRgKJTE9jIR8Yby/F3kycoCsx0rLS9pE2Al8lh1DHBqqZdXG9YCzkcnrjtJewE/BrYHfkpemX9lea2dh7N0TH3RodtFx5W5kzT0NNoa+AjwL6A7+dCW2zGAcqqXz5P73u3kOUQVPY+WkbQD8Alg4YiYKWlRScsOMi4AyknjvwHsovYfqVDrsqhDG9cXPY8TewJ3RcTUkjA7lFzOsyPi5PI/swb6YZLWiIiZZK+3F4H3SxrjcxGzvrXzQa97x90B+EpE/CYifhcRHyHnPfuppGWAFYGdyeGce0XE34elwMPjZGBLoIs8aZtCDmncDdqvUVNOLk8hr56cS55g7kMOu+y3C7KkL5BXSm4HPk0eNJ4C3g+sFhHXR8RbI+Ig4FWS/gcgIl6s/tsMTulyvTQwGvg7uRx+CBwpaVEfvNqbpFHK+SpeA9xRGjrvA37fTkMChoKkU8nl8OXy/EhyWVzXrsn8mownT3jeDjxJzsl4OXkV+XfAOsNXtN514rqTtC45JOshch7MZ4EdgWPKFfQ57ZZI67T6okO3i44rc6cp7ZKtgU8BNwHTyH2PdtyO4aWpPw4j241/IpMTDwFjJe080CSPpDWB04GzyITijZLeRs5RtVoF5T6bPEd7A9mjeXdJEwYbtw51L4s6tGN90cdx4pqS5Op2JjA2Ik4o/6eBllnZo/SdkraIiHvI85LNgYma1yOtrc4lzdqF2r1toZzDYHZEfLX00nmx/P0LwJyI+EhJNoxpx2RJnSTtRzYI9gHWiIj9JJ0LTI2IE4e3dP+tHGj/B/gQsFJE3NTC/y5OHlh+A1wHzIiIHSSdQF6l+QfwkYh4uuF/VoiIR6v8DoNVttXXkAfB2cB2wPFkj4qzgNXJIcnntdv8bZYk7UImSf5O3ilpDHAAcEBEPNHwvnER8cLwlHJolJ6hKwKXkYnwtYBtgf17LIuuwczV0QkkrUNezNiS7BV1HzCXTPj8gzyZ+GZEXDqYRm9VOnHdKXvvbgUcRd6tbDQ5XHaf8vsUcuj+M5JGtcOJfafVFx26XXRcmTuNclqVmZQkCdnzfxmy58qdEfGZ0r5ZNyLuGL6SzlMSaJ8gE35HA28FNgDeTba7lgaOGEg9IenN5EXh68iLuhsAHwTOiYgfDrLcXyF7SO1fnp9GJtPeFxG/U85FN61HYmXY1Lks6tCO9UXZv56g/+PEmsA6EfGL8nxQbQnlKJ69yelkViaPrwcBrwDOBl4fEU+2y/HUrJ205QS3ksZHxHPl6RRyjPY3ImJ66aUzjbxbyebw0jxgC1QCrVgHeA95x5YHJb2fTMyMg8FXrjWYQ3ZTXoK8qjYmIv4IfZe1JFIXInudLQmcB6wv6RSyF+J15B1bz5P03oh4CqDdEmjw0pXcsWQPipvJm2G8FdgxIp6X9ErgjcBmwB+Gr6TWG+Wkq1uQ+xzkEPKxZJJkc+UcRxPIBu9Fkn7ZZvtgZbobohGxb3l+Mfm9LyHn+lsVeJBMcNwl6daGen3EKL0D3g6sD/yE3KcfBu4mh138iUz4XEP2Er50uLcJSWcCK3TSupO0PdnjfDY5vcM/yfp/B+CvwOPk8XCypCMi4pnhKek8nVZfdOI+3Yll7jRlO/4CeWL/EzJ5Ngk4KCKmSfqhpA8C3wbeIuneiJgxfCV+aQjnwWTdcD2wHjns+0AyibZLRGxW3rtYRExtIfbW5AiId5P10TvLZ90J/FXSHsDrgN8CN3e3SZuMfQ457/N+5fl7yWPLYcA9pZft64E5kn7cBseS2pZFHdqxvijrdDPmncfO7zixJ3BhFQk0SSsDawC3RsQ3JH2TvMB/ckQ8Bjwm6TvAJZJelsgzs9R2SbSSjT9C0lTgkxHxTUlbAldI2q2hd844YIxyPrA5gz2Q1HXFoepElqRXAE+WSn17MoF0C7A1eQXjObIyhuwK3vJ3krRwRAx4fH0v8bqXwdrk0Jt7gAeATSUREX8syaX5LatbyNs8zyoH4G9KOpa8E+cNwEmRk8RuA5wv6W1VXTGpYv2VA+TipXfE+uTcHNuTc7p9lBzy1QUQEXcru/HfO7iSV6/TruJ3rztJo6u6YhsRM8pV4YPI4chjyQlf1yN7Gm1Irrubuhs6I5GkpYDzu3scSDqc7H11D3mFd3NyAtx/k3eT+gstXugoPbueqLrRXcN2sTU53OKcEv8J8mTz5+R8no8CvyJPNNaSNLGxx2wrZa6grN0ujYhrS+zDqHjdlbjLRMR/qiispMWAp8lG/l1kgvKVZPLy3lLWvYCdyMnDjwC+WMVnD0bd9UWV28VQ7NNVG6oyS9owIm6vqNg9Yy8UOXl4W5L0qoj4u6QzyCHry5IJtKMa2uMHA18C3ku2bb4EtJREq7J9oeyxehuZeDiHHHJ6ONkj7ZPkfjelJHhWBNaTdGJ/60E5JckjZG+r7sTGRLJn7GLAtWSi40WyLX4f0HTvUuUc0NMbEmhHkhdZD4mIh6SXpviYAmwdET9qNnaJV2V9UeuyqEM71nHKEUW/JUenHEDfx4lbIuLy7v+tYF1uD4xX3uV6VeACMpG4ZUT8iUyyLUtemNq3fGTTn1ll27tH3Fo7iLR7nWzto62SaOWA9imyG/BRZLfxwyPiKEmfB/4k6VJAwH7Am6vY0CW9sfx8DJgSEYNOYJSD3VKR3WBfC6wC/DgGMeRU0jvJLsfXS/oVcAJ5peJScm6KS8gK9zp4ad6tVj/jROA+Sb+KioYTNlR2G5ancyT9EtidvMoSEfFf8xBIejvwk4j4Q3n+bkl7A/9H3kDgNcCVJYH2FjKxenIVCbSq1p9yLoFjyKuhV5FJzePJK4vdXd5XAg4py6QLuDcifjrY71ClOvaROjUkSnYCNpB0zmASw6Vu2hl4PiI+oex9tAPwPXJY/FVlm9kyIm7sWY5WytzwvLLu8xWfoHyBvKL/vvL8/WR9vCM5LGKfiLhI0iURMX3+keYbfwmyQbsFcLekf0VFvUpr2C7OAcZHxMHKO6jtT/aIWorsLTWL7EFwOHki8Tlym2m6vFR4HJG0Z0T8siGBdmwp807Amgxy3TV8zheB1SV9NiJuG2icEut0so68GPgluY09RxnCT9anRwIHR8TDyjllfjqAzxlFXoB6LiLuHmSZa60vatguat2n6zAUZS7LeSXgk5IuaDyBrYKk3cmT+DOrjFsVSeeTJ/SHkMO93kAmcN4fEY+VfUYR8WJZ/pDbZdO9usrnVNa+UPaMWo28+Lo2cBGZPPsQmUD7e0TsLOkqcn//G3BGX+cSDdvB/5DJ+TeUBPmhZP15F5nkuA54MCJ+12KZFekPlBEIko4gkyr7lWW9MDm1TZQk4eslnRkRzzYTn4rqi7qXRV3asY5T9ggfGxE/KM8Xp+J25fyUpOztwDZk8vAtZCeHA4DXSPoc8LeI2EA51UBLbVFJawNvk3RN9zlcFRracK8DXoyIG6qKXeK3dZ1s7aVtJguUtDrwNbJiv5ocX7+WpA8pu4l/kryD4QPkFek3RgU3EVDeTWYSmZj5CjkevAqLkxXR4eTElbsAO2mAEzRKejeZ9PwBmTCbVU5OViQnST0nIm4FNiIbOQP5jOPISf+PosKbE2jeJM9LknejJCKeLL8/AWwnaavy3u67P51KJglPk7RQOTHagFxHC5PJqMvIifi/RF7pPymquwtnVetvk1LWP5bnJ5JXaOcCb4mI35NXTF8kl/mzEXEUVLPsq1DjPlKbhkTJZ8mrd4NJlCxDJnxfB9wkaS0ykb87cD85fGVdyjDjnuVo8jO6GwY7S/pa+d+5VW0DJXE9StLlknYbSAxJEyR9hmyAX0DejetN5AnLgaXhuQo5JxjkNt79v03dJKOcKFxA9jBajtz3thlIeXtT8XZxHrBNRBxc/rQoOQzkWrL32T3kd/hERFxHLo+9I4dKNKuy44ikDwEflrRuw/8vBLytXDDpns8NBrDuGt5/Bnkx4Ntk/bxeq2VtiHUm2cvhQvJEfnaJvR5Zt/4N+CrZI/mZ8m/HRk6Q3Mrn7AdMJk8Kl5W0vnII20DKXHt9QUXbxVDs01UbyjKXxMZD5B2091EmRyuhvDP5lynTkrQb5bC3RSPikPKnqcC3gMMi4hGVizzl2KLy+9xocdhXle2LkiDagGxPfR+4lWxzfYZsG29CXiS+nDwB/0xE/CQiHuwrbsN28EXKUFDlELt3kjfJ+hJZ3z8N7Fi+U9PbWzkubaWcjB9l0n0L4LSG40V3Am1/8qLMu5pJoBWVHUfqXhZVa9c6rrQfNgM+UI43rySPdXtQ3XGi52ceLemA8vvPgVeRCeZ3AM+U9tAvyWPtvRFxbPnXlpKKpdyblnIvXv42oONpT2Uf2JScQ3rlEnt0FbHbvU629tNOPdFmkRXw6LIhnwT8njwpWYucj6Hf7tatKBVpF1mZnk32bnpS0tqtNsJ7MYY8+duZHFs/jRy+F+TwvWbLuBbZXfpB8oraceTB6S4yATUVuCwifqvsqUZEXNlqYSV9gBwC8zuyMTNG0obADpK+GwMcUlUaWnMkrUjOhfZSYyUipih71O1EHnQhG6ofB34bEZsqbxxwADkc6qryPZ8g57VYj5yf4zCyQTHYddZo0OtPOWHnu8kk56jSKF2WPKFakXLFMSL+Jmk2mUTbS9JFZINp2CfxrHkfqVzZX4JMXnwc+FBE/KFsf8tGxF9aiDWKPEh/l9x2jyTv8HUEecfgmZIeIYeynE9etbtggEVfRNLmpcyPSvp2RBxcEmkD7kUmae+I+Fl5+m0ygXuSpBnlYkWzcV5Bnkh2kY3nJcirzsuXnwuXt95NLiOiYU6cFhp965JDKP5K7tcvkFdHu8sxoCuwVW4XJd4ZJdZNmjefzqbksLwnJD1D7vdfL1fpR8XAJtseVD1UTgJ2IU9wpgJ3AKPLdrVCidfdy+9eBrfuunvmbUDWZWeQFxCOVfZIe6DZOCXWWcDcyJ7o5wCPRcT55YRtOXIy5JnkRYjpwAHKoZMD6Y3VfSJ1PTkEaWPyGNP0kLQhri+qOD4N1T5dmaEss7InxtNkgucGMpF7mHIKikH1SFP2st+WHKr32sHEqkP57usBu5bnx5BlfXPkHGhqbJ8M4qT+TVTbvriRrH9OJkcx/Lp8ztvIOuliss54hhwF0O8xZX7bAVlffKa0Sd8L3B0Rl5U6t3vb63O5qNz8Snlh68vAZeV4/31JV5J3mX8C+EtEzCoJtKPImyG0csG4qvOR2pZFHdq1jlOOrBpPzpN6Mtkb7lTyxkP/LseJd5DnxHcO4jjR03fJuTffR0438QQ5Qmhp4HDlDSKOA/4YEUeXsqqV9mdpU21NHvvvAyaVvx0p6byIeGSghVf2Mn0r8GryXHW5EvsgSRe1msDvEbut62RrT8Pe06U70x8RD5MTx/+bHNJ5bUQcHxHfIyuaMRUn0N5DXnn/JdlQWJNMarxIHhCQtO0A4q5dfn2KrJjvLle5niV7P+yvnOOtWa8lT3K+Uf7/r2TlsSlAqZB+XrL8E8lGQktXUEqi6nDypO9rZAN/6fL7g4NIoHWVk7WVyOE1d5X1/JIS+0cxb46gzclE2+clbUxeJXkN8CPgREk7RsT/Ab8mTwa/AbwmKuiVWMpcyforJ1Qnko2X6WTj7tXkunwD2YNiUUlrAJQG0eXA/0bErOFocPRU1z5Ss0XJ9fR58q5cXcohyt+i7DPNKicJy5E9KK8nGz2HAMuVE+LVyCuJFwA/JhtBA+m5sxG5r30FOCbyjlwPSPpmqw2YHnFFJhY+Jun7wP0RsQ85BO4zyh5ZzTqUvFL7HHnc2Iusm54FPgAcqhyKsD95l8SBlHdZshv9NPKiyT1kb9QlJH1F0uaD2C8q2y4kfR3YMCLeBJwQ84YuHUVuL5ANyHeQdXL3ttTKZ1R1HBlPNtLHRkR3Hf9G5bD4i4BRDdvXgNddKfPp5Lw4PyB7Cf+DbJAvB7woaVwLsc4k680TlXecXg24vyTT3k82/EXO2fJqchl9KSKmN7uNKHtm7q+cE+5ssgfhYuTV81+Tw1EnNFvmoagvKm5f1L5P12BIylyS5OuRFxS/QSYfFiZ7K+6rQfRIk3QQece7I8neRkuWvw97exxe6oG2JTlSYH3lkO+9gXdGjiCoJLlQZftC0iTlHF27kr1r5pA32zpCORLiqojYOyJOItuXD1B6rvaTQOttOxhNJjc2o8xlS/aeW6L8/otoYs7LcjHgEOVF4w+Tya0ngLdKOjDyrpYPkheZ15J0CJmQbzqBVmV9UeeyqFHb1XHKIdLrRsSB5E2HViHrgN3yZa1DDju9CPgZA2xX9iYiukcpLUre/OhtwOrl9xuYd5GtO4E2qsULD6OAx8jk2RXkkMhVyvd4ZKAJtIbvvhNZF10REceRSeCfkNMmPDHQZdTudbK1r2HfQLp3UGXvs33JxucFwEyVbsBk74Q1JC1WRUWiHLqxGlnRf5tM0OxNNvg/TjbQAdaR9IYWw28l6Y/k/FcTyZOH1wDfIb/fncDHJe3YRDnfSZ4oTCbnc1gqcvLqrckrVLuVA/Ge5FWmdchuwK0MI3s/OU/Pg+SVsHtKvP3J3oC3l4Mnykk5m1ISaN090H4IfCsivlJee9k67D7BlPRWcsjLx8m5CtYmewJsQ141Oxw4QdLrIuIq4BTl8K8qVbX+TillP5w8mX6KbHhsRlb6zwH/SybZAIiIe6IN7igHte8jlWvYptYi55T4WuRQ2ankzRv+2Xg1T3mH1P5i7gGcTt4tdTK5rpYCtlD24hlHbqPjyCFlj0BrQzjLrxuQV8CuKuUlIj5W/nZqM7F6ib0rmaz9KLkNjouIjyknaL+fbIx/VHllr79Yp5CTzr6T7Jp/DLmc/0x+90OAH0TE82Qj7Ps9vl9/8UdL+h/yjlS7k+vvrhJ7Q/LkYhvyjnBIGt9M3B5lqGS7KEmcV5J3hoScV+1KZS/CKyLi1hJjAvAfcqj6QI5ZldRDkcN97gCmSTqKrNNXJXv4XRzzboawEHklvqV1103SR4A1I6L7au4z5DK+lDzJmghcqrR4P7GOBt4UER8ik1sPRMSeEXEWeQJ3F3mi/T1y+SwDPB0Dm8NzG7LH2bPkBZxXksmD7cmeCzsr5+jrV931RVHJdlH3Pl2HoSqzpAvI3gj7lpjHkNvzm8rnXEgm0vYcwHd4F7BTzBsCLuD50l5qh57n5wMTI2In8gT/RPJGHSdExH0N73u1cl6ugX5OZe0L5dCu48nt4k3A4xGxDdmb9CSyx9nTknaV9GVynU6OiD4nue9jO9ibrN8vJOd8eiPZg+735V/7XY+SFDmMMMhk1CFkMmNX8mLaDspe5D8gE34Hls9/X4s90KqqL2pbFnVpxzpO2bt6ZfIi6ZuAo0vZ3kMed95CHjuWLMezs8gE12B6e75e0smS1ijrcRzZzvoi8HCpixYnL+x/ICK654xTK3VSOf5tTa7z0RHxOHlsfgd5Qa3lEVLdIl4awrkreYH1H5KOJ/f370bEueWtO7daL9VZJ6uiYaZWjZIzuVvSvcrpTXq+PkHSzyX9n6Q7lPM89mnYk2jKq8Fd5PC2j0XEnWQi7e/ArsrhGYeTQzmnDvYKmLK3wxQygfF6spH7v+SB4EPlte3KDro8mZhqxW1k4+CzZKX0HNn76HhyDp5TySvpxyjnTplfOZciG/izyAp2U7Lr6oVkRRvkyfcZ5fm/gA+30musnDg9RF51/wt5pWrn8nl/IU+CziXvhrkjedfUfse190ig/Qj4fkScXV7rq+v8b8mE264R8TWyN8MnyKt0/yEbRR8HjpO0JNnluOpeW7cxyPWn7L3QfReoU8iDym/Iq2D3kuvtLOD0sr23lSHYRypXDrKvI3suXQw8VU5+Tyd7H01UdtfuTta+R/Pm6vsvyl4jJ5DJ5NXIpNMK5MnvKmRSdwcywb91RMyOFnvKljLvQg6HOJls3L1e0jqSPkpuQ//TSsyG2L8mr6x+lUza3qUcivFBMjH3ALlcXt/Xgb7sZ7NLnPHkd1+T7G10HtlYnkb2GOoie1O2OnxjAplkPpNM6D9FSZiTQ9+CvKr5VkkHk431pubXqHK7UE44OzYitgPeK2m7iLie3De+QR7DiJyseSuy0fjjAdZPtzH4eqj7ZGAWWa9OJ7eFY8hkzkqSVte8O1H9ngEMvVFeyPg38BvlPCvXkw3do8gTgIfJE8OPkAm249X3xY8fAN+XdBfwaEScKun9yrlRn4+In0XElRHxeGQP5Av7OyGej03I4+oN5HFwRXJdbkwm6a4qv++uTD73tQxWo+b6oriNwW8XQ7FPV2qoyixpC/L49gPyhO1a4IflosYfyWTGkmQ75CSVuVybjD0R2CIi3lWed5H7xiLkNA5jy9+Ha+6oZYAZJREOmVTelpyCYm9J35F0mqT/JeesXKWvY2gfn1N1++JJMjGwNTlq5ZXKXtafIkdAbE5eMJlAJsvfFxH391PGVraDD5Dzqz0IzW1v5bi0K3l825esi44hE/Cbk4mW9Usi7bvklC67RusjLm5j8PVFrcuiDu1Yxyk7hXRFxB7ksXgf4HnyQtF48viwD/DpcjFOETEnBn9DqKfJi0PvJxN0j5E3ffhyKdfeZDL0bcBzkrrUeg+0MWTyaT2yrXZ+OWc8ilzePwX2LAnclikv9k4m79Y+mdzeTiHrhjUknSHpYjIxunI/7YvGuLXVySXWb5QXiG2YlfVxDplAXpccpbNuj7e9jxw+vRG5P57eXyJ02OdEixzuNxF4BfDPUpGfRO4wU5l3d5qBzCfT2+c9Lqm7t9s9ZPb/48ALEXGcpMlkd845ZKP63PkG690i5EHmerIB8DkyIfjbiLipvGcjctnP99a/EfGUpG+X915Xyvlvcjk9Sx4UPhk5P8WA7uIXEbMlXUF2wxbZVfZt5BWZF8gk1oHl9U8A74mG+QJ6M58E2ks90PqqmCPnSPs6maz7Ejms5lzy4PYdMik1l1zGUdOV20Gvv8jeHz9RXnValhyC+wbyoLU+mTD5YERcPtB1V6ch2EcqVyrI5cgT2SCv8D0CfCFybo6VgC9J2o5MIBzZT+NkKtlwPIJMiJxC9tBckVx/q5En2ssxr1dSq2VenGzkHRMRvy5l3J5MJi0UETuX9y0cA5sAf0/g/yLiQ5L2IfeZnyrvtDRV0vrk0Jf5NhDKPvlp8iTlLWRi7knyCvamZP18JNkof1/3vt6KyHksvlbWzThyfzufTO7/m0xwbEteKLiTvHra1FxVFW8X10TEFeX3ScB+km6JiG+U/1+nfObu5OTA3x9gogSqqYe669qVyAska5DDpd5Qyvpxcs7Gv0n6cwywF2zkXD0/IU+wHiFP3D5K9jBZkuyNdghZd59KTkw+3+05cljGeeV73yppLzKx+ueI+IdyiNeSZIP6xma3hV48Vsq5K3ki/0z5fSGy7rufTAZuSM4f05fa64uiiu2i9n26akNY5lsj4s/KCdgPIhMP75T0DnIf+hi5TqeSx/am5+CJHNZ2JOQFzNL+upI8jm4IvEHSL2OY7n4aEf8hT7QpCaw9gO3I5Pet5IWCZcghzzeW/2n5BL/K9kU5WV6/lOnKiPiOcuL0jcnRFT8mExZbkj2dj4vm5k1qdjuYxrybIjRNeQF7c+ASMnGyBzn64igy4bEXOdXAxpK67944kGGRVZyP1Los6tCmddwNEfF7ZU+pDcj1/G5ymPjJ5LI7NnJeuSrPC2Yw747hW5IX1CaQ6+5ssg77JnmMjgHu0zMk3URuX38h97WLgEsi73g6njy27ijpbxHxXIsf8XCJuYayp/re5P5wOdmL8AoyOTy3leVWZ51czoM/Tc5z+FhEfL3VGFapLcibZdwHIOkScjtq7MgSwOIlaTqO3Mb6bsNHxLA+yN5wh5IHvFPJ7tw7lNeWJ4cwVv2ZiwI7l98XIg/iPyBPNo4HPlVe6xpg/K3Jk8BbSrw3UDLk5O3Cv0nesri/OCIr2PFk5XQqeYJ9GtlD5Qdkz4gqlsl6ZG+pC8vzFcgD+unkHGzrtBBrRbIiPabxu7Tw/8uQPSYOJJOFvyXHq0N2zV675m1y0OuvbGNbkQfKa8jkyJrAzcy74+CoGsq+fNmmFxpknFr3kZrW26iG7e8e8q6Ija+/j0zENLUtkwnr75NzkFD2h4+W7fLo8rdFKtjWvtUdh0yq3UzWg2sMMvbaDb9vSV41XrE8X5mci2bjJmNtSSZFPkAm1z9JJvfXKt/ht4MpL3nA2pMcTgDZqLyMHCJI9zpoh+2i4f9+Tp5YLkxefDi17Ce/A15VwfZc1XFkEnmS+UtyPpiNy3r7HNkj9nWD3Y7L5yxOnmRdTJ4UrlHKfhp5BfDaZpcL2S7YjWw4d+8bi5LHo1PLcli6gjJvQp5U7FPW501kL5s1yZ4svwBe2WSs2uuLireLWvfp+XzmoI5PQ1Xmsu2eWH7/OjkcaZOyn+9e/r7sID9D5WcX2SPrGGCXKpf3AMu1HtmLtrvu/Syl/dWj3E236Xr5jErbF2Ry+ntksuiysp7OIxOAZ5b3jGun7YBs5x5NHu/XJ0/mLyLrvlNL+dcGJgxyfVZVX9S+T/TymR1RX7RYpq6yvr9MJvhOIROTp5MdGQZ9jOjxeYuX7WhTciTMh8rfzycTCF+s6HOWKtvXd8p+/Aby3H5CeX1/skPBgI/b5IWLP5Htgs+V+O8he3QuWsF3qLxOJqfw+St5J9gh285G4mPXHRaNzTYc0+sD+FU/6+EtwAUNzw8GvtrjPYsDV5MX718A9uyvTN0bzLAqXW93ILt8EkNYqJIp3pns+bYSmXn8Y0Tc3l/PqX7i7kxW3Acyr1fX5yPiWs0bPtNsrNVKGaeQQ0+2KOU8AXh7DGwoS8/POJjMvq9HXiG7iawUNwXeERF3NxlnFHni8HTMm29noHfUW5u8UnJGlDuOahB3KmzxsytZf8q5Px4tj3PIRt3O5LL9WAysh9H8PuvV5BwmvyMbONcCcwa7P9W1jzTEH002dm6LnJ9iUJS3Cj+STG7MiYhjJb2e3C5buquV8q6OZ5Mn2t0nF7OBjSLijIq+/5bkCfdTZMP6Y2QCdjXg8oi4fZDxR0dObH46uS89Uq7gj212eSuHs00jh1keSg4H/Ql5FfMEsnHdylwt8/uc7p6sh5MNmQ3JYXVbketvwMO3q9wuSryzyUTPVWSSZLZycutHInt1DFoV9VC5qvZGYIWIOE85QfUi5AnqOVWUs+GzFiGv5q1KnmgdS94Y5ijgLdHCcKRyxf4cslH+d3LY06iI+FyF5V2M7CE3kRxKdhc5T9Ny5TscHxFN9xwbivqifE4V28WQ7NMNnzfo49MwlPm95InthcCXgEsjh7FVFf+l7aH0XH8B+Phg2jiDPZ6WY8PoKDdMUU58f1tEXDbQMvXzeZW0LyStStZzU8kesWPIemMX8uLwQHus1rYdKKcW2J/saT0+IvYqozAWiTI3VRUqPh+pdZ9o+JyOqy/KZ/a7/5WeiKPIZNB+5AWbGWRy7ZIq2sG9fOYhZPLwGfKi4U/IHlw/jrzrdSW935TDfz9PLvfNyfX3OfK4+nhE3DvAuKPIC1yLlnbMGWT7YDWys8J3ovUebr19Th118gZkYvyAKsq4oNpsozFx/a9W7PW1sSvc/wDZ27Tb5Mihv8BL07W8PiIOK88PJofyHtPwnreQHVxOIC8a/IZsu81/nQ0kG1jngyHs2UIeZN9OTuIIuaPvAixWUfytyYPM5cApg4w1mhzm+o1SznfRYs+J/pZF+bkYeSeV/cnE5koDiLVYw+8D6m1FnsD8inKFq/xtwFc+h2v9lfW2RInxxvK3XwDr1VTe7cgTwAH33Om5XdS5j5SYa5IH3OMrijeOeb1ZP0+e0H6YcmV9APHWIocWHtywTleueN3tSF6RXrg8fwU5IeuSFX7GJcBeg/j/UeTVxZXInjvnk1d1q6yHunvffpq8wvgWMrG4XDttF6Wc25X943PA96rcHnp8VhX10EINv68ALNG4Xisu78JkT+n1yQs+v2eAPfPKfvHWsg2s0/D3So8FZI+KE8lG/xfJntRrDTBW7fVFhdtF7ft0j/IO+vg0xGVeiewJM4ac0mKVmra/9cgLpINuF1D98fS7gzlu9BO70vYFOWrjm+Sw6s+Rk/Uv3s7bAZnA/yA5tO9icq7c7tcqq5urqC/qXha9lLej6ovyeU3tf2TP+N+Qc911l7OydnUvnzeB7H24NnnBaGfyQuUyFX/OKLL31aLkyKmtK4w9uuH375PtglqWW5V1com3MNmmP7KudTzSH5tsODqmPbparw/g5n6W/9bkkP/u5x8m55FvfM8vgdc2PP8dmWibf9zhXijD/WDeSeu2ZHfnVSuOvyM5R8wG5flgusCvSZ5YDrpR0MdnjCUbTa8Y5vWyBE0Oo6m5HINef+TJ+1qNz2sqa/dQiHeQ3bQnVRS31n2kxF6HbEhWst3R0Pgkk8+rDDLeduQQwwl1rLvyGd09gxcqPyu5oNAQ9/TGA8QAYzU2YnajhuRAib0pOdzh4CobSFVuF411ATnkadCJvj4+q7LjyFA9SplvZBBDW8mhqCv3+Fvl3508oVmv/L42gzyxGIr6oqrtYgj36cqOT0NV5obPOIBMslYyfUYv8VcY7DbXI14lx1Oyl8cXyF5SdS3bStsX5FDy7ckLzoM67g/VdlDquRPIqT+WKn+ro56r8nyk7n2ik+uLfvc/8rxgjfJ75VO79FO+48ge07V8LnmRsYscSrt8998qjL0ZOfR5TI3LqNI6ucR8DdmzacjW9Uh6bLzhwvHsIyv3+qD/JNpCwH3khZXR5NyN6/V4z7nkXPOQQ4cfoZ/hx20xnLMdlKEjoyPikRpibwH8M1q4c2YfsVYih0pOG3zJeo0/CngvefedSoYkdbqq1l9VQ3n6+YxlyF5MT0fEPRXHrnMfGUU2li6LnOyzkphR0eSs5bsfBJwXeffFWtS5jZQhHXdHxEN1xK9SGYK4JnBfVDx8u+LtYshuDFLlcaRuZUjL24HrosmpAEaSoaovymd10nZR2/GpLqUu2g74R0Q8OtzlaUZVx1PljVnWJrev+d4IqwpVtS+UN84Z9BQnvcStdTuQtBQ5L+iP6mrfl88ZdH0xVPtEJ9YXUE97tkrKG03dUecyVd7Z8mTgy1HxEMYy5PwVC2LbYkG28Uaj46orlun1taVXfOSWiNi8r/+XtAfZO7KLHOL/WUlHAkQOEV6B7A28PJmsPTUivtNnTCfRrKfuOZSGuxy2YGl1bo6h5v1iaA1F0tnqM5QJxnbk+mLk6MS6qKrjaSd+97rUvSw0RHP+VsHbRd/avT07FOo8Bnr7W/BstNHouPLypXt9bfmV/t1vEq0OCw31B1r7c8PfhkO7Nzi8XwwtN5A624KcQAPXFyNJJ9ZFVR1PO/G716XuZdEpCTTwdtGfdm/PDoU6j4He/hY8QTCL9lrtTqKZmZmZmZmZmVlbiYBZ7ZVDcxLNzMzMzMzMzMzaSyBmhYa7GC8zargLMBCSjui02J0Wt87YnRa3ztidFrfO2J0Wt87Yjlt/7E6LW2fsTotbZ+xOi1tn7E6LW2fsTotbZ+xOi1tn7E6LW2dsx60/dqfFrTN2p8WtO/ZIF8BMRvX6GC4dmUQD6twI64rdaXHrjN1pceuM3Wlx64zdaXHrjO249cfutLh1xu60uHXG7rS4dcbutLh1xu60uHXG7rS4dcbutLh1xnbc+mN3Wtw6Y3da3Lpjj2gBzIpRvT6Gi4dzmpmZmZmZmZlZWwnEnDbr+6V2ucHFaI2JsSzW1HtnMYOFGdPUe2e+YpGWyjHnual0jW+uHDG3+bG5c56fStfizcVdddyTTcd99uk5TJjY1dR7H3x6UtNxAeZMnUrXYs2Veb2l/9N03CefmsvSSzW3Izwwc/Gm4774zIuMXWJsU+99fmqL28ULU+ka19yyeMUSzS+LZ56ewxJNrr/7nmt+/bVS3mXGPdd0XICpT89isYkLN/XeJ6ZMaDpuK9vb+ks/0XTcJ56aw6SlmlvG/5o5rum40No2N3XW6KbjznluGl3jF23qveNGz2g67otTZjB2yebqzllzm1tmADOfmc7oJZrbp2bOaT4uwOxnp7HQhOaWxaQxLzQd94Upsxi3ZHPb8WPTxjcdt5W6fuzo1m7g1cpyXqyr+e1i2pSZLLpkc9vnMzObrztbWXcTx0xrOi7A1KdnstjE5sr83Kzm9lGAmc9OZ/SE5r5jl5pvP814Zjpjmlx3L85u7fpmO9QX02c3ty8BzHp2Ogs3uYzHdrW2j7RSJ7fS+m0l7uhRzd9kcdqUGSza5DJ+flZz7+s2+9npLNTkcl5oVPM3022lHprbwhw2dW4X06e8yCJLNrf+ptW0LY/uan67mDHlRcY0Wd5WljG0tv6ihdit1J20UORWyjunhfOyVtYdwOwW2i6tnEvyYvOJgVbayS00AZj94lQWGttkeYGuGc3XF7NmTWXhhZuLrdkt1EOzpzF6oeaOe8xpIe7c6Ywe1cI5Ygs3Ip8590VGj2puv35u9pNPRkRrJ+4j2DobjokLf75ir69ts9r9t0TE5kNcpPbpiTaWxdhSO1Ue98EvblB5zG4zpjZ/UtyKc157cS1xj/p+fb1Ibzz0nFriHvbQ9rXEvfbG9WqJC3DR3mfXEne/q95bS9xjt/5tLXEBzvvRHrXE/fPhX6sl7uEPbVNLXIAbH121lrivXem+WuI+Oq35BGgrHnqunrgAh69xXS1xv3TrrrXEXWfFx2qJC/DqJR+oJe5lD65fS9z9V7+llrgAv3583VriThg9vZa4/3iqvnbzViv8q5a4dzy9fC1x11qi+QsmrZpT0yTFqywypZa41z6+Zi1xASaObS2J3awX59RzmrH2+OYvVrbqL0+uXEvcVRavZ7uoaxln7OYTiq0Y1cIFiFZMebG1C+SteGJK8xf1W9F1d/PJq1aM/2d9nWQm3FfPsW+hJ5u/ENoKTa2nvAAxvZ7YVz45uZ5GXIfKGwu0TdoKaKMkmpmZmZmZmZmZGWSv2JnR2kiWujmJZmZmZmZmZmZmbSWAWTiJZmZmZmZmZmZmNl8ezmlmZmZmZmZmZtaPwMM5zczMzMzMzMzM+hTQdj3Rmr+vbiFpe0lr11EYMzMzMzMzMzOzQMyJ3h/DpamUnqQLge57Pq8JPCWp+17NUyPiTZJ+C0yYT4jpEbHd4IpqZmZmZmZmZmYLgoj264nWbGk+Daxafj8bOBmYXZ4/DhARO3e/WdJ7gBci4rsVldPMzMzMzMzMzBYQeWOBzpwTbUlgNeA1wD+AlRpemwvc1eP9o5mXZDMzMzMzMzMzM2taRybRJO0KnFTeuy5wH/B2MrE2DZgh6Y/AGxr+bXngRUknNvztUxHxix6xjwCOABjLooP4GmZmZmZmZmZmNlK0440F+i1NRPxa0jXA94AbgUvLS5sCmwD7RsRzwKe6/0fSn8geajtGxPQ+Yk8GJgOM18QY6JcwMzMzMzMzM7ORox17ovV7d05JmwJXAysAvwLuLY+rgKWAX0javeH9bwbuBM4CPlFDmc3MzMzMzMzMbASLyCRab4/h0ky/uIeAtwHvAw4Hni1/Hw3cQw7tHAcgaWfgI8AuETFF0lsl7RURl1VecjMzMzMzMzMzG5FyOGd79URrZjjnEwCSAI6JiOvK82WB8yJiqqQlJE0GVgR2i4gp5d8PBS6StC9wWkT8rY4vYWZmZmZmZmZmI0cgZs3tsCRaD2dKeqb8Php4tPw+BvhhRPym8c1lrrR9JW1DE0NHzczMzMzMzMzMAOa0WSqp6SRaRHwY+PB8XruPvGvn/P73utaLZmZmZmZmZmZmC6JAzO604ZxmZmZmZmZmZmZDKQJmzW2vnmjtVRozMzMzMzMzM1vgBYO7O6ek3STdLeleSR+az3t2kHSbpDskXdNfTPdEMzMzMzMzMzOzthKI2QO8sYCkLuAcYBfgYeAmSZdFxJ0N71kC+Bp5g8wHJS3TX1wn0czMzMzMzMzMrK1EwKwY8ADKLYB7yxz+SLoE2Bu4s+E9BwKXRsSD+Xnxn/6CKiIGWqBKjdfE2FI7VR5Xm69fecxuz35mei1xZ1zWb/JzQHY6/MZa4gL86dOvriXuo9vWM+J4863vqSUuwL0XvbKWuOPe9u9a4j5x9Qq1xAXYZ78/1BL32k9sXUvcR7etb9LKrlWm1hJ37v2L1RJ3zri5tcQdteTMWuICjL19kVrijt7mqVriTnl4Qi1xAcY+Xs81splr1XPcG3NXPesOYPrKs2qJqxn1HJ+6lp5RS1wAHqpnOc+eVM8y7nq6xmu9qifsQi/Us13MWKm+ulPT6zn2xUL1nGMsPKW+Y/WsZevZlkc9W8+2XNcyBoiuemKPmlnPPqI5tYQFYPQz9ZR50cfqWcYT7quvvhj9eD3t2VHPPF9L3JheT7sFIGbWU1/8+rmLbomIzWsJ3oGWetWk2OPivXt97TtbfeMB4MmGP02OiMndTyS9hexhdlh5fjCwZUQc3fCeM4GFgfWAxYGzIuJbfZXJPdHMzMzMzMzMzKytBDB7/j3Rnuwn4djbJbOe2euFgM2AnYBFgBsk3RgR8+114ySamZmZmZmZmZm1lxj4nGjkPGgrNzxfCXi0l/c8GRFTgamSrgU2AuabRPPdOc3MzMzMzMzMrK0EMBf1+mjCTcBaklaXNBrYH7isx3t+BrxW0kKSFgW2BP7eV1D3RDMzMzMzMzMzs7YSwOy5A+v7FRGzJR0NXAl0ARdGxB2SjiyvnxcRf5f0K+B2YC5wQUT8ra+4TqKZmZmZmZmZmVlbCTTgJBpARFwOXN7jb+f1eH4acFqzMZ1EMzMzMzMzMzOz9hJ93lhgWNSWRJO0dEQ82f87zczMzMzMzMzM5hnMcM66tFwaSQdJes98XvuopO0lLQ78eNClMzMzMzMzMzOzBU4g5swd1etjuDTVE03Sz4ClyETgMkCXpLeTk7PNAQ4CjgWeLv9yEDBJ0g0NYS6OiPOrKriZmZmZmZmZmY1M0cHDOfcBrig/9wHGRcT5kn4OHFnijC7vXRF4K7AV8EXgUxHx70pLbWZmZmZmZmZmI5iGtddZb5oqTUTMBS4Btu3+m6TNgGsi4pEeb18COCYingNOAU6opqhmZmZmZmZmZragiFCvj+HSb080SbsDH+l+CmxBJt/+DMyRtDdwQcO/3AEcL2l9YGFgtqSbgMMj4rYesY8AjgAYy6KD+yZmZmZmZmZmZjYiRMCcucOXMOtNv0m0iLiCHMqJpFOB6cBs4J8RcXT5+6rA5g3/tlJEbC3pIuC48lisl9iTgckA4zUxBvNFzMzMzMzMzMxsZAhgTifOiSZpFPApYBpwMTAOGCvpDOCDtZXOzMzMzMzMzMwWQGq7nmj9pvQkrQNcDUyJiE93/z0izgLuBq4h50E7peHfxkj6A7AH8CvgXRWW2czMzMzMzMzMRrAImDt3VK+P4dJMT7QAjo6Iv/7XC3mHzj8Ci0bE49JLGcIZEbFj9xNJn6iktGZmZmZmZmZmtkBot55ozcyJdneP59/t8fyOht8/CyDp1h5hTgHmDryYZmZmZmZmZma2oAg0rL3OetPUnGitiojnejyfU8fnmJmZmZmZmZnZCBQwNzqsJ5qZmZmZmZmZmdlQi04bzmlmZmZmZmZmZjbUIoa7BC/nJJqZmZmZmZmZmbWVCIgFYU40MzMzMzMzMzOzwYg2u0XliE+ijZo2s7bY43f/Z02R64l7+7m1hAVgEf5cS9w1flpLWKbUExaApbihnsAX1BN2Jf5VT2Dgps931RK3tu3tZ7WENevVpOEugJmZmQ0f1TTPk+rrtVNXLmNuu2VJrI3Ic6KZmZmZmZmZmZn1KXxjATMzMzMzMzMzs/6Fk2hmZmZmZmZmZmbzF4B7opmZmZmZmZmZmfWt3abMcxLNzMzMzMzMzMzaj4dzmpmZmZmZmZmZ9SFAndYTTdIN/bxlW2Ar4OvAKOA5YAXgW8Bry3vWAfaJiD8OvKhmZmZmZmZmZrZgUEfOifZCROwCIOkQYHZEfLc8v7rhfVcAo4F7gF2BM4EngOeBRZ1AMzMzMzMzMzOzpg2iJ5qk3YCzgC7ggog4dT7vezVwI7BfRPyor5ijBl6c/zKnPGaTX3MqcCtwJPCnCj/HzMzMzMzMzMxGsgDNVa+P/kjqAs4BdgfWBQ6QtO583vcF4MpmilTlnGh7kUm51wLLAeeTBV0KuETShRHxmQo/z8zMzMzMzMzMRqoY8H9uAdwbEfcBSLoE2Bu4s8f7jgF+DLy6maDNJNG2aJgXbVL58KPL83UBIuI6YB1JHwBui4iryvtWBT4G/AV4oGdgSUcARwCMZdFmymtmZmZmZmZmZguAPnqdLS3p5obnkyNicsPzFYGHGp4/DGz5stjSisA+wI5UmET7c39zoknaFDgdWBl4QdIUsstct0nABT0Dly84GWC8Jg48v2hmZmZmZmZmZiNH0NecaE9GxOZ9/Hdv2beeeaczgZMjYo7U3A0MKhnOGRF/AV7XS0+07tc/XcXnmJmZmZmZmZnZgkEDv7HAw2RHr24rAY/2eM/m5PRjAEsDe0iaHRE/nV/QSoZzSloF2IycD21nSccDnwEeayK+mZmZmZmZmZnZyw18zOJNwFqSVgceAfYHDnxZ6IjVu3+XdDHwi74SaNDicM6euodzAhsAryCHZv6dnP/sHcBXgG838RlmZmZmZmZmZmYAKPqcE61PETG7dAC7EugCLoyIOyQdWV4/byBx+02izS+BVl57Xfn1l+XR6OLyMDMzMzMzMzMza8kghnMSEZcDl/f4W6/Js4h4ZzMxK5kTzczMzMzMzMzMrDIxuCRaHZxEMzMzMzMzMzOz9uMkmpmZmZmZmZmZWd808BsL1MJJNDMzMzMzMzMzay8ezmlmZmZmZmZmZtYEJ9GGVjz07+EugpmZmZmZmY3qqifsImNriQswatlJtcSd+sp64j67+sK1xAWYvmw9cWeNrydLMneR+rIvGjunnsCH/LCeuB1KuCeamZmZmZmZmZlZ38JzopmZmZmZmZmZmfXPPdHMzMzMzMzMzMz65uGcZmZmZmZmZmZmffHdOc3MzMzMzMzMzPrnJJqZmZmZmZmZmVlfgrabE23UQP9R0oaSlunnPYtLOkDSewf6OWZmZmZmZmZmtmAReXfO3h7Dpd8kWkmCPS7pakn/kfR6SaOAbwM7l/esJ+mG8ni3pPUlXVXesyxwWa3fwszMzMzMzMzMRhTN7f0xXPpNokXE94HfRcTrgGsi4krgcOBC4K2SlgXGAb8CTgRWIhNn10bEmyLizIh4pLZvYGZmZmZmZmZmI0/M5zFMmh3OuZGk3wCLSNoD2AX4F3A88B1gbD3FMzMzMzMzMzOzBU50YE+04v8iYhdgOvAq4EDypgSvAt4P7NDj/WOBw8rwzv9I+oukfXoGlXSEpJsl3TyLGQP+EmZmZmZmZmZmNrK0WxKt2btzbizpamAqcDZwXcNrtwAXAbs1/G0p4IsRcbaki4BPRsQDPYNGxGRgMsB4TRzGDnlmZmZmZmZmZtY2YngTZr1ptifabWVOtOkRMRPYqjzOBf5Q3nMYJSEGLA08WmVBzczMzMzMzMxswSA6sCeapDWBNSR9HniNpK2BScCdwF7APsAGwOci4tzyP5cAv6+r0GZmZmZmZmZmNrJpbnsNWmxmOOck4Ezgr8DaEXGDpLWAnwEfjYgAbi8PJC0NbALcWkuJzczMzMzMzMxsZOvE4ZwRcUNEfC8i/grMLX/7B7ATsL+knjE2AM4syTUzMzMzMzMzM7OWddxwzkYR8daG3x8D9u/lPVcDVzc8P3QwBTQzMzMzMzMzswVMG/ZEaymJZmZmZmZmZmZmNiTabIyjk2hmZmZmZmZmZtZW8u6c7ZVF63dONDMzMzMzMzMzsyEVg5sTTdJuku6WdK+kD/Xy+kGSbi+P6yVt1F9M90QzMzMzMzMzM7O2ozkD/D+pCzgH2AV4GLhJ0mURcWfD2+4Hto+IKZJ2ByYDW/YV10k0MzMzMzMzMzNrLzGo4ZxbAPdGxH0Aki4B9gZeSqJFxPUN778RWKm/oCM+ifbUvuvXFnvJi2+oLbaZmZmZmdlIolGqJ/Co+mYpiq56Ys8dXc+ymDO2lrAZe5F65qaau0hNt18cXeNtHUe11zxdI1kfQzeXlnRzw/PJETG54fmKwEMNzx+m715m7wau6K88Iz6JZmZmZmZmZmZmnUURffVEezIiNu/r33v5W6/BJL2OTKJt21+ZnEQzMzMzMzMzM7O20+xNBHrxMLByw/OVgEf/K760IXABsHtEPNVfUN+d08zMzMzMzMzM2o6i90cTbgLWkrS6pNHA/sBlL4strQJcChwcEfc0E9Q90czMzMzMzMzMrL0EMGdg889FxGxJRwNXAl3AhRFxh6Qjy+vnAR8HlgK+Jglgdj9DRJ1EMzMzMzMzMzOz9jOIu3MSEZcDl/f423kNvx8GHNZKzNqGc0qaJGmjuuKbmZmZmZmZmdkIFTknWm+P4dJyTzRJhwDjIuKchr+tClwL3AesSd7R4HBgoqQrgf9ExA3VFNnMzMzMzMzMzEYyARrgcM66VNkT7XsR8TrgR8DqZJe4XwMbA/tU+DlmZmZmZmZmZjaSRQ7n7O0xXJpKokkaL+mDvfz9M5K6ytMDJP0G2Bc4BXgPsCewC3BGReU1MzMzMzMzM7MRr/cEWtsn0YAdgQm9/H0mcEhEPACsAbwQEasAO5C90DYC/hkRj/UWVNIRkm6WdPMsZrRceDMzMzMzMzMzG4Eih3P29hguzSbR9gF+3svfzwKOLXOifQxYRNLngd3JYZ0nAddI+pGkdXv+c0RMjojNI2LzhRkzsG9gZmZmZmZmZmYjz9zo/TFM+r2xgKT1gRUi4saer0XEc5KuJ3ueQfZMuxh4N7Ah8Mny91WBxQdfXDMzMzMzMzMzWxAo2uvGAs3cnXND4OQ+Xr+EeUm0OeQdOs8AJkXEoQCSfh4RfxpEOc3MzMzMzMzMbEERQJvdnbPfJFpEfK/Hn9Tj9WskCfg0eVfOq4CPVlZCMzMzMzMzMzNboIhAc+cOdzFeppmeaACUec9+DCxK3nmz0RLAecBvIuIJSROA3SRd3fC6mZmZmZmZmZlZ/zqxJ1q3cgfOzefz2k97PH8WWH5QJTMzMzMzMzMzswVWx/ZEMzMzMzMzMzMzGxIR4CSamZmZmZmZmZlZ39SpwznNzMzMzMzMzMyGRABz3BPNzMzMzMzMzMysDx7OaWZmZmZmZmZm1r/wcM5ePc+UJ38bP3qgybcvDTzZ1Dsv+lGrRWk+9siOW2fsTotbZ+xOi1tn7E6LW2dsx60/dqfFrTN2p8WtM3anxa0zdqfFrTN2p8WtM3anxa0zdqfFrTN283FndVhcgOdqin1PTXFbM7K3t/aI22rsVWsqQ2eKgDlzhrsUL9M2SbSImNTseyXdHBGb11GOumJ3Wtw6Y3da3Dpjd1rcOmN3Wtw6Yztu/bE7LW6dsTstbp2xOy1unbE7LW6dsTstbp2xOy1unbE7LW6dsR23/tidFrfO2J0Wt+7YI57nRDMzMzMzMzMzM2uC50QzMzMzMzMzMzPrg4dzVmZyB8butLh1xu60uHXG7rS4dcbutLh1xnbc+mN3Wtw6Y3da3Dpjd1rcOmN3Wtw6Y3da3Dpjd1rcOmN3Wtw6Yztu/bE7LW6dsTstbt2xR74264mmaLM7HZiZmZmZmZmZ2YJtwkKTYusl9un1tSuf+votwzHXXKf2RDMzMzMzMzMzs5HMNxYwMzMzMzMzMzPrQ0TbDeccNdwFMDMzMzMzMzMz6ynmzOn10QxJu0m6W9K9kj7Uy+uS9JXy+u2SNu0vppNoZmZmZmZmZmbWXiJyOGdvj35I6gLOAXYH1gUOkLRuj7ftDqxVHkcA5/YX10k0MzMzMzMzMzNrK8GgeqJtAdwbEfdFxEzgEmDvHu/ZG/hWpBuBJSQt31dQJ9HMzMzMzMzMzKy9RAwmibYi8FDD84fL31p9z8v4xgJmZmZmZmZmZtZWnmfKlb+d+79Lz+flsZJubng+OSImNzxXL/8TPZ43856XcRLNzMzMzMzMzMzaSkTsNoh/fxhYueH5SsCjA3jPy3g4p5mZmZmZmZmZjSQ3AWtJWl3SaGB/4LIe77kMeEe5S+dWwLMR8e++gronmpmZmZmZmZmZjRgRMVvS0cCVQBdwYUTcIenI8vp5wOXAHsC9wDTg0P7iKqLP4Z5mZmZmZmZmZmYLPA/nNDMzMzMzMzMz64eTaGZmZmZmZmZmZv1wEs3MzMzMzMzMzKwfTqKZmZmZmZmZmZn1w0k0MzMzMzMzMzOzfjiJZmZmZmZmZmZm1g8n0czMzMzMzMzMzPrhJJqZmZmZmZmZmVk//h9qVKQNkGilAQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1764x180 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = 子女 父母 父爱 无比 温暖\n",
      "output = <BOS> 他 的 爱 、 残疾 、 父母 之间 都 有着 我 的 生活 ； 有人 不要 父母 之 余 ， 为 父母 付出 ， 我们 都 应该 尊老爱幼 的 人 。 我们 要 从小 安利 ， 对 子女 着想 奉献 、 爱护 他人 ， 甘愿 我们 是 父母 。\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1800x180 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = 信念 人生 失落 心灵 不屈\n",
      "output = <BOS> 学生 ， 每 一个 人 都 能 读书 。 有 的 人生 ， 有 动力 的 信念 ， 在 路 上 ， 有 许许多多 的 经历 ， 还有 的 像 理想 ， 有 的 拼搏 ， 有 的 拼搏 ， 有 理想 的 爱 。\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1656x180 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input = 体会 母亲 滴水之恩 母爱 养育之恩\n",
      "output = <BOS> 中国 ， 我 仿佛 的 一切 都 无法 感受 到 了 生活 之中 的 变化 。 在 那 浮华 的 飞逝 中 ， 我们 应该 珍惜 的 是 一样 奢望 的 。 在 生命 的 时候 ， 要 珍惜 珍惜 ， 珍惜 才 长大 。\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1656x180 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluateAndShowAttention(['妈妈', '希望', '长大', '孩子', '母爱'], method='beam_search', is_sample=True)\n",
    "evaluateAndShowAttention(['现在', '未来', '梦想', '科学', '文化'], method='beam_search', is_sample=True)\n",
    "evaluateAndShowAttention(['春天', '来临', '田野', '聆听', '小路'], method='beam_search', is_sample=True)\n",
    "evaluateAndShowAttention(['子女', '父母', '父爱', '无比', '温暖'], method='beam_search', is_sample=True)\n",
    "evaluateAndShowAttention(['信念', '人生', '失落', '心灵', '不屈'], method='beam_search', is_sample=True)\n",
    "evaluateAndShowAttention(['体会', '母亲', '滴水之恩', '母爱', '养育之恩'], method='beam_search', is_sample=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
